%* glpk02.tex *%

 \chapter{Basic API Routines}

 This chapter describes GLPK API routines intended for using in

 application programs.

 \subsubsection*{Library header}

 All GLPK API data types and routines are defined in the header file

 \verb|glpk.h|. It should be included in all source files which use

 GLPK API, either directly or indirectly through some other header file

 as follows:

 \begin{verbatim}

    #include <glpk.h>

 \end{verbatim}

 \subsubsection*{Error handling}

 If some GLPK API routine detects erroneous or incorrect data passed by

 the application program, it writes appropriate diagnostic messages to

 the terminal and then abnormally terminates the application program.

 In most practical cases this allows to simplify programming by avoiding

 numerous checks of return codes. Thus, in order to prevent crashing the

 application program should check all data, which are suspected to be

 incorrect, before calling GLPK API routines.

 Should note that this kind of error handling is used only in cases of

 incorrect data passed by the application program. If, for example, the

 application program calls some GLPK API routine to read data from an

 input file and these data are incorrect, the GLPK API routine reports

 about error in the usual way by means of the return code.

 \subsubsection*{Thread safety}

 Currently GLPK API routines are non-reentrant and therefore cannot be

 used in multi-threaded programs.

 \subsubsection*{Array indexing}

 Normally all GLPK API routines start array indexing from 1, not from 0

 (except the specially stipulated cases). This means, for example, that

 if some vector $x$ of the length $n$ is passed as an array to some GLPK

 API routine, the latter expects vector components to be placed in

 locations \verb|x[1]|, \verb|x[2]|, \dots, \verb|x[n]|, and the location

 \verb|x[0]| normally is not used.

 In order to avoid indexing errors it is most convenient and most

 reliable to declare the array \verb|x| as follows:

 \begin{verbatim}

    double x[1+n];

 \end{verbatim}

 \noindent

 or to allocate it as follows:

 \begin{verbatim}

    double *x;

    . . .

    x = calloc(1+n, sizeof(double));

 \end{verbatim}

 \noindent

 In both cases one extra location \verb|x[0]| is reserved that allows

 passing the array to GLPK routines in a usual way.

 \section{Problem object}

 All GLPK API routines deal with so called {\it problem object}, which

 is a program object of type \verb|glp_prob| and intended to represent

 a particular LP or MIP instance.

 The type \verb|glp_prob| is a data structure declared in the header

 file \verb|glpk.h| as follows:

 \begin{verbatim}

    typedef struct { ... } glp_prob;

 \end{verbatim}

 Problem objects (i.e. program objects of the \verb|glp_prob| type) are

 allocated and managed internally by the GLPK API routines. The

 application program should never use any members of the \verb|glp_prob|

 structure directly and should deal only with pointers to these objects

 (that is, \verb|glp_prob *| values).

 \pagebreak

 The problem object consists of five segments, which are:

 $\bullet$ problem segment,

 $\bullet$ basis segment,

 $\bullet$ interior point segment,

 $\bullet$ MIP segment, and

 $\bullet$ control parameters and statistics segment.

 \subsubsection*{Problem segment}

 The {\it problem segment} contains original LP/MIP data, which

 corresponds to the problem formulation (1.1)---(1.3) (see Section

 \ref{seclp}, page \pageref{seclp}). It includes the following

 components:

 $\bullet$ rows (auxiliary variables),

 $\bullet$ columns (structural variables),

 $\bullet$ objective function, and

 $\bullet$ constraint matrix.

 Rows and columns have the same set of the following attributes:

 $\bullet$ ordinal number,

 $\bullet$ symbolic name (1 up to 255 arbitrary graphic characters),

 $\bullet$ type (free, lower bound, upper bound, double bound, fixed),

 $\bullet$ numerical values of lower and upper bounds,

 $\bullet$ scale factor.

 {\it Ordinal numbers} are intended for referencing rows and columns.

 Row ordinal numbers are integers $1, 2, \dots, m$, and column ordinal

 numbers are integers $1, 2, \dots, n$, where $m$ and $n$ are,

 respectively, the current number of rows and columns in the problem

 object.

 {\it Symbolic names} are intended for informational purposes. They also

 can be used for referencing rows and columns.

 {\it Types and bounds} of rows (auxiliary variables) and columns

 (structural variables) are explained above (see Section \ref{seclp},

 page \pageref{seclp}).

 {\it Scale factors} are used internally for scaling rows and columns of

 the constraint matrix.

 Information about the {\it objective function} includes numerical

 values of objective coefficients and a flag, which defines the

 optimization direction (i.e. minimization or maximization).

 The {\it constraint matrix} is a $m \times n$ rectangular matrix built

 of constraint coefficients $a_{ij}$, which defines the system of linear

 constraints (1.2) (see Section \ref{seclp}, page \pageref{seclp}). This

 matrix is stored in the problem object in both row-wise and column-wise

 sparse formats.

 Once the problem object has been created, the application program can

 access and modify any components of the problem segment in arbitrary

 order.

 \subsubsection*{Basis segment}

 The {\it basis segment} of the problem object keeps information related

 to the current basic solution. It includes:

 $\bullet$ row and column statuses,

 $\bullet$ basic solution statuses,

 $\bullet$ factorization of the current basis matrix, and

 $\bullet$ basic solution components.

 The {\it row and column statuses} define which rows and columns are

 basic and which are non-basic. These statuses may be assigned either by

 the application program of by some API routines. Note that these

 statuses are always defined independently on whether the corresponding

 basis is valid or not.

 The {\it basic solution statuses} include the {\it primal status} and

 the {\it dual status}, which are set by the simplex-based solver once

 the problem has been solved. The primal status shows whether a primal

 basic solution is feasible, infeasible, or undefined. The dual status

 shows the same for a dual basic solution.

 The {\it factorization of the basis matrix} is some factorized form

 (like LU-factorization) of the current basis matrix (defined by the

 current row and column statuses). The factorization is used by the

 simplex-based solver and kept when the solver terminates the search.

 This feature allows efficiently reoptimizing the problem after some

 modifications (for example, after changing some bounds or objective

 coefficients). It also allows performing the post-optimal analysis (for

 example, computing components of the simplex table, etc.).

 The {\it basic solution components} include primal and dual values of

 all auxiliary and structural variables for the most recently obtained

 basic solution.

 \subsubsection*{Interior point segment}

 The {\it interior point segment} is automatically allocated after the

 problem has been solved using the interior point solver. It contains

 interior point solution components, which include the solution status,

 and primal and dual values of all auxiliary and structural variables.

 \subsubsection*{MIP segment}

 The {\it MIP segment} is used only for MIP problems. This segment

 includes:

 $\bullet$ column kinds,

 $\bullet$ MIP solution status, and

 $\bullet$ MIP solution components.

 The {\it column kinds} define which columns (i.e. structural variables)

 are integer and which are continuous.

 The {\it MIP solution status} is set by the MIP solver and shows whether

 a MIP solution is integer optimal, integer feasible (non-optimal), or

 undefined.

 The {\it MIP solution components} are computed by the MIP solver and

 include primal values of all auxiliary and structural variables for the

 most recently obtained MIP solution.

 Note that in case of MIP problem the basis segment corresponds to

 the optimal solution of LP relaxation, which is also available to the

 application program.

 Currently the search tree is not kept in the MIP segment. Therefore if

 the search has been terminated, it cannot be continued.

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \newpage

 \section{Problem creating and modifying routines}

 \subsection{glp\_create\_prob---create problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 glp_prob *glp_create_prob(void);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_create_prob| creates a new problem object, which

 initially is ``empty'', i.e. has no rows and columns.

 \subsubsection*{Returns}

 The routine returns a pointer to the created object, which should be

 used in any subsequent operations on this object.

 \subsection{glp\_set\_prob\_name---assign (change) problem name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_prob_name(glp_prob *lp, const char *name);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_prob_name| assigns a given symbolic

 \verb|name| (1 up to 255 characters) to the specified problem object.

 If the parameter \verb|name| is \verb|NULL| or empty string, the routine

 erases an existing symbolic name of the problem object.

 \subsection{glp\_set\_obj\_name---assign (change) objective function

 name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_obj_name(glp_prob *lp, const char *name);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_obj_name| assigns a given symbolic

 \verb|name| (1 up to 255 characters) to the objective function of the

 specified problem object.

 If the parameter \verb|name| is \verb|NULL| or empty string, the routine

 erases an existing symbolic name of the objective function.

 \subsection{glp\_set\_obj\_dir---set (change) optimization direction\\

 flag}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_obj_dir(glp_prob *lp, int dir);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_obj_dir| sets (changes) the optimization

 direction flag (i.e. ``sense'' of the objective function) as specified

 by the parameter \verb|dir|:

 \begin{tabular}{@{}ll}

 \verb|GLP_MIN| & minimization; \\

 \verb|GLP_MAX| & maximization. \\

 \end{tabular}

 \noindent

 (Note that by default the problem is minimization.)

 \subsection{glp\_add\_rows---add new rows to problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_add_rows(glp_prob *lp, int nrs);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_add_rows| adds \verb|nrs| rows (constraints) to

 the specified problem object. New rows are always added to the end of

 the row list, so the ordinal numbers of existing rows are not changed.

 Being added each new row is initially free (unbounded) and has empty

 list of the constraint coefficients.

 \subsubsection*{Returns}

 The routine \verb|glp_add_rows| returns the ordinal number of the first

 new row added to the problem object.

 \newpage

 \subsection{glp\_add\_cols---add new columns to problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_add_cols(glp_prob *lp, int ncs);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_add_cols| adds \verb|ncs| columns (structural

 variables) to the specified problem object. New columns are always added

 to the end of the column list, so the ordinal numbers of existing

 columns are not changed.

 Being added each new column is initially fixed at zero and has empty

 list of the constraint coefficients.

 \subsubsection*{Returns}

 The routine \verb|glp_add_cols| returns the ordinal number of the first

 new column added to the problem object.

 \subsection{glp\_set\_row\_name---assign (change) row name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_row_name(glp_prob *lp, int i, const char *name);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_row_name| assigns a given symbolic

 \verb|name| (1 up to 255 characters) to \verb|i|-th row (auxiliary

 variable) of the specified problem object.

 If the parameter \verb|name| is \verb|NULL| or empty string, the routine

 erases an existing name of $i$-th row.

 \subsection{glp\_set\_col\_name---assign (change) column name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_col_name(glp_prob *lp, int j, const char *name);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_col_name| assigns a given symbolic

 \verb|name| (1 up to 255 characters) to \verb|j|-th column (structural

 variable) of the specified problem object.

 If the parameter \verb|name| is \verb|NULL| or empty string, the routine

 erases an existing name of $j$-th column.

 \subsection{glp\_set\_row\_bnds---set (change) row bounds}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_row_bnds(glp_prob *lp, int i, int type,

       double lb, double ub);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_row_bnds| sets (changes) the type and bounds

 of \verb|i|-th row (auxiliary variable) of the specified problem object.

 The parameters \verb|type|, \verb|lb|, and \verb|ub| specify the type,

 lower bound, and upper bound, respectively, as follows:

 \begin{center}

 \begin{tabular}{cr@{}c@{}ll}

 Type & \multicolumn{3}{c}{Bounds} & Comment \\

 \hline

 \verb|GLP_FR| & $-\infty <$ &$\ x\ $& $< +\infty$

    & Free (unbounded) variable \\

 \verb|GLP_LO| & $lb \leq$ &$\ x\ $& $< +\infty$

    & Variable with lower bound \\

 \verb|GLP_UP| & $-\infty <$ &$\ x\ $& $\leq ub$

    & Variable with upper bound \\

 \verb|GLP_DB| & $lb \leq$ &$\ x\ $& $\leq ub$

    & Double-bounded variable \\

 \verb|GLP_FX| & $lb =$ &$\ x\ $& $= ub$

    & Fixed variable \\

 \end{tabular}

 \end{center}

 \noindent

 where $x$ is the auxiliary variable associated with $i$-th row.

 If the row has no lower bound, the parameter \verb|lb| is ignored. If

 the row has no upper bound, the parameter \verb|ub| is ignored. If the

 row is an equality constraint (i.e. the corresponding auxiliary variable

 is of fixed type), only the parameter \verb|lb| is used while the

 parameter \verb|ub| is ignored.

 Being added to the problem object each row is initially free, i.e. its

 type is \verb|GLP_FR|.

 \newpage

 \subsection{glp\_set\_col\_bnds---set (change) column bounds}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_col_bnds(glp_prob *lp, int j, int type,

       double lb, double ub);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_col_bnds| sets (changes) the type and bounds

 of \verb|j|-th column (structural variable) of the specified problem

 object.

 The parameters \verb|type|, \verb|lb|, and \verb|ub| specify the type,

 lower bound, and upper bound, respectively, as follows:

 \begin{center}

 \begin{tabular}{cr@{}c@{}ll}

 Type & \multicolumn{3}{c}{Bounds} & Comment \\

 \hline

 \verb|GLP_FR| & $-\infty <$ &$\ x\ $& $< +\infty$

    & Free (unbounded) variable \\

 \verb|GLP_LO| & $lb \leq$ &$\ x\ $& $< +\infty$

    & Variable with lower bound \\

 \verb|GLP_UP| & $-\infty <$ &$\ x\ $& $\leq ub$

    & Variable with upper bound \\

 \verb|GLP_DB| & $lb \leq$ &$\ x\ $& $\leq ub$

    & Double-bounded variable \\

 \verb|GLP_FX| & $lb =$ &$\ x\ $& $= ub$

    & Fixed variable \\

 \end{tabular}

 \end{center}

 \noindent

 where $x$ is the structural variable associated with $j$-th column.

 If the column has no lower bound, the parameter \verb|lb| is ignored.

 If the column has no upper bound, the parameter \verb|ub| is ignored.

 If the column is of fixed type, only the parameter \verb|lb| is used

 while the parameter \verb|ub| is ignored.

 Being added to the problem object each column is initially fixed at

 zero, i.e. its type is \verb|GLP_FX| and both bounds are 0.

 \subsection{glp\_set\_obj\_coef---set (change) objective coefficient

 or constant term}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_obj_coef(glp_prob *lp, int j, double coef);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_obj_coef| sets (changes) the objective

 coefficient at \verb|j|-th column (structural variable). A new value of

 the objective coefficient is specified by the parameter \verb|coef|.

 If the parameter \verb|j| is 0, the routine sets (changes) the constant

 term (``shift'') of the objective function.

 \subsection{glp\_set\_mat\_row---set (replace) row of the constraint

 matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_mat_row(glp_prob *lp, int i, int len,

       const int ind[], const double val[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_mat_row| stores (replaces) the contents of

 \verb|i|-th row of the constraint matrix of the specified problem

 object.

 Column indices and numerical values of new row elements must be placed

 in locations \verb|ind[1]|, \dots, \verb|ind[len]| and \verb|val[1]|,

 \dots, \verb|val[len]|, respectively, where $0 \leq$ \verb|len| $\leq n$

 is the new length of $i$-th row, $n$ is the current number of columns in

 the problem object. Elements with identical column indices are not

 allowed. Zero elements are allowed, but they are not stored in the

 constraint matrix.

 If the parameter \verb|len| is 0, the parameters \verb|ind| and/or

 \verb|val| can be specified as \verb|NULL|.

 \subsection{glp\_set\_mat\_col---set (replace) column of the

 constr\-aint matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_set_mat_col(glp_prob *lp, int j, int len,

       const int ind[], const double val[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_set_mat_col| stores (replaces) the contents of

 \verb|j|-th column of the constraint matrix of the specified problem

 object.

 Row indices and numerical values of new column elements must be placed

 in locations \verb|ind[1]|, \dots, \verb|ind[len]| and \verb|val[1]|,

 \dots, \verb|val[len]|, respectively, where $0 \leq$ \verb|len| $\leq m$

 is the new length of $j$-th column, $m$ is the current number of rows in

 the problem object. Elements with identical row indices are not allowed.

 Zero elements are allowed, but they are not stored in the constraint

 matrix.

 If the parameter \verb|len| is 0, the parameters \verb|ind| and/or

 \verb|val| can be specified as \verb|NULL|.

 \subsection{glp\_load\_matrix---load (replace) the whole constraint

 matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_load_matrix(glp_prob *lp, int ne, const int ia[],

       const int ja[], const double ar[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_load_matrix| loads the constraint matrix passed

 in  the arrays \verb|ia|, \verb|ja|, and \verb|ar| into the specified

 problem object. Before loading the current contents of the constraint

 matrix is destroyed.

 Constraint coefficients (elements of the constraint matrix) must be

 specified as triplets (\verb|ia[k]|, \verb|ja[k]|, \verb|ar[k]|) for

 $k=1,\dots,ne$, where \verb|ia[k]| is the row index, \verb|ja[k]| is

 the column index, and \verb|ar[k]| is a numeric value of corresponding

 constraint coefficient. The parameter \verb|ne| specifies the total

 number of (non-zero) elements in the matrix to be loaded. Coefficients

 with identical indices are not allowed. Zero coefficients are allowed,

 however, they are not stored in the constraint matrix.

 If the parameter \verb|ne| is 0, the parameters \verb|ia|, \verb|ja|,

 and/or \verb|ar| can be specified as \verb|NULL|.

 \subsection{glp\_check\_dup---check for duplicate elements in sparse

 matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_check_dup(int m, int n, int ne, const int ia[],

    const int ja[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_check_dup checks| for duplicate elements (that

 is, elements with identical indices) in a sparse matrix specified in

 the coordinate format.

 The parameters $m$ and $n$ specifies, respectively, the number of rows

 and columns in the matrix, $m\geq 0$, $n\geq 0$.

 The parameter {\it ne} specifies the number of (structurally) non-zero

 elements in the matrix, {\it ne} $\geq 0$.

 Elements of the matrix are specified as doublets $(ia[k],ja[k])$ for

 $k=1,\dots,ne$, where $ia[k]$ is a row index, $ja[k]$ is a column index.

 The routine \verb|glp_check_dup| can be used prior to a call to the

 routine \verb|glp_load_matrix| to check that the constraint matrix to

 be loaded has no duplicate elements.

 \subsubsection*{Returns}

 The routine \verb|glp_check_dup| returns one of the following values:

 \noindent

 \begin{tabular}{@{}r@{\ }c@{\ }l@{}}

 0&---&the matrix has no duplicate elements;\\

 $-k$&---&indices $ia[k]$ or/and $ja[k]$ are out of range;\\

 $+k$&---&element $(ia[k],ja[k])$ is duplicate.\\

 \end{tabular}

 \subsection{glp\_sort\_matrix---sort elements of the constraint matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_sort_matrix(glp_prob *P);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_sort_matrix| sorts elements of the constraint

 matrix rebuilding its row and column linked lists. On exit from the

 routine the constraint matrix is not changed, however, elements in the

 row linked lists become ordered by ascending column indices, and the

 elements in the column linked lists become ordered by ascending row

 indices.

 \subsection{glp\_del\_rows---delete rows from problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_del_rows(glp_prob *lp, int nrs, const int num[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_del_rows| deletes rows from the specified problem

 ob-\linebreak ject. Ordinal numbers of rows to be deleted should be

 placed in locations \verb|num[1]|, \dots, \verb|num[nrs]|, where

 ${\tt nrs}>0$.

 Note that deleting rows involves changing ordinal numbers of other

 rows remaining in the problem object. New ordinal numbers of the

 remaining rows are assigned under the assumption that the original

 order of rows is not changed. Let, for example, before deletion there

 be five rows $a$, $b$, $c$, $d$, $e$ with ordinal numbers 1, 2, 3, 4, 5,

 and let rows $b$ and $d$ have been deleted. Then after deletion the

 remaining rows $a$, $c$, $e$ are assigned new oridinal numbers 1, 2, 3.

 \subsection{glp\_del\_cols---delete columns from problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_del_cols(glp_prob *lp, int ncs, const int num[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_del_cols| deletes columns from the specified

 problem object. Ordinal numbers of columns to be deleted should be

 placed in locations \verb|num[1]|, \dots, \verb|num[ncs]|, where

 ${\tt ncs}>0$.

 Note that deleting columns involves changing ordinal numbers of other

 columns remaining in the problem object. New ordinal numbers of the

 remaining columns are assigned under the assumption that the original

 order of columns is not changed. Let, for example, before deletion there

 be six columns $p$, $q$, $r$, $s$, $t$, $u$ with ordinal numbers 1, 2,

 3, 4, 5, 6, and let columns $p$, $q$, $s$ have been deleted. Then after

 deletion the remaining columns $r$, $t$, $u$ are assigned new ordinal

 numbers 1, 2, 3.

 \subsection{glp\_copy\_prob---copy problem object content}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_copy_prob| copies the content of the problem

 object \verb|prob| to the problem object \verb|dest|.

 The parameter \verb|names| is a flag. If it is \verb|GLP_ON|,

 the routine also copies all symbolic names; otherwise, if it is

 \verb|GLP_OFF|, no symbolic names are copied.

 \newpage

 \subsection{glp\_erase\_prob---erase problem object content}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_erase_prob(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_erase_prob| erases the content of the specified

 problem object. The effect of this operation is the same as if the

 problem object would be deleted with the routine \verb|glp_delete_prob|

 and then created anew with the routine \verb|glp_create_prob|, with the

 only exception that the handle (pointer) to the problem object remains

 valid.

 \subsection{glp\_delete\_prob---delete problem object}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_delete_prob(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_delete_prob| deletes a problem object, which the

 parameter \verb|lp| points to, freeing all the memory allocated to this

 object.

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \newpage

 \section{Problem retrieving routines}

 \subsection{glp\_get\_prob\_name---retrieve problem name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 const char *glp_get_prob_name(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_prob_name| returns a pointer to an internal

 buffer, which contains symbolic name of the problem. However, if the

 problem has no assigned name, the routine returns \verb|NULL|.

 \subsection{glp\_get\_obj\_name---retrieve objective function name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 const char *glp_get_obj_name(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_obj_name| returns a pointer to an internal

 buffer, which contains symbolic name assigned to the objective

 function. However, if the objective function has no assigned name, the

 routine returns \verb|NULL|.

 \subsection{glp\_get\_obj\_dir---retrieve optimization direction flag}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_obj_dir(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_obj_dir| returns the optimization direction

 flag (i.e. ``sense'' of the objective function):

 \begin{tabular}{@{}ll}

 \verb|GLP_MIN| & minimization; \\

 \verb|GLP_MAX| & maximization. \\

 \end{tabular}

 \pagebreak

 \subsection{glp\_get\_num\_rows---retrieve number of rows}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_num_rows(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_num_rows| returns the current number of rows

 in the specified problem object.

 \subsection{glp\_get\_num\_cols---retrieve number of columns}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_num_cols(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_num_cols| returns the current number of

 columns the specified problem object.

 \subsection{glp\_get\_row\_name---retrieve row name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 const char *glp_get_row_name(glp_prob *lp, int i);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_row_name| returns a pointer to an internal

 buffer, which contains a symbolic name assigned to \verb|i|-th row.

 However, if the row has no assigned name, the routine returns

 \verb|NULL|.

 \subsection{glp\_get\_col\_name---retrieve column name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 const char *glp_get_col_name(glp_prob *lp, int j);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_col_name| returns a pointer to an internal

 buffer, which contains a symbolic name assigned to \verb|j|-th column.

 However, if the column has no assigned name, the routine returns

 \verb|NULL|.

 \subsection{glp\_get\_row\_type---retrieve row type}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_row_type(glp_prob *lp, int i);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_row_type| returns the type of \verb|i|-th

 row, i.e. the type of corresponding auxiliary variable, as follows:

 \begin{tabular}{@{}ll}

 \verb|GLP_FR| & free (unbounded) variable; \\

 \verb|GLP_LO| & variable with lower bound; \\

 \verb|GLP_UP| & variable with upper bound; \\

 \verb|GLP_DB| & double-bounded variable; \\

 \verb|GLP_FX| & fixed variable. \\

 \end{tabular}

 \subsection{glp\_get\_row\_lb---retrieve row lower bound}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 double glp_get_row_lb(glp_prob *lp, int i);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_row_lb| returns the lower bound of

 \verb|i|-th row, i.e. the lower bound of corresponding auxiliary

 variable. However, if the row has no lower bound, the routine returns

 \verb|-DBL_MAX|.

 \subsection{glp\_get\_row\_ub---retrieve row upper bound}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 double glp_get_row_ub(glp_prob *lp, int i);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_row_ub| returns the upper bound of

 \verb|i|-th row, i.e. the upper bound of corresponding auxiliary

 variable. However, if the row has no upper bound, the routine returns

 \verb|+DBL_MAX|.

 \subsection{glp\_get\_col\_type---retrieve column type}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_col_type(glp_prob *lp, int j);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_col_type| returns the type of \verb|j|-th

 column, i.e. the type of corresponding structural variable, as follows:

 \begin{tabular}{@{}ll}

 \verb|GLP_FR| & free (unbounded) variable; \\

 \verb|GLP_LO| & variable with lower bound; \\

 \verb|GLP_UP| & variable with upper bound; \\

 \verb|GLP_DB| & double-bounded variable; \\

 \verb|GLP_FX| & fixed variable. \\

 \end{tabular}

 \subsection{glp\_get\_col\_lb---retrieve column lower bound}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 double glp_get_col_lb(glp_prob *lp, int j);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_col_lb| returns the lower bound of

 \verb|j|-th column, i.e. the lower bound of corresponding structural

 variable. However, if the column has no lower bound, the routine returns

 \verb|-DBL_MAX|.

 \subsection{glp\_get\_col\_ub---retrieve column upper bound}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 double glp_get_col_ub(glp_prob *lp, int j);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_col_ub| returns the upper bound of

 \verb|j|-th column, i.e. the upper bound of corresponding structural

 variable. However, if the column has no upper bound, the routine returns

 \verb|+DBL_MAX|.

 \subsection{glp\_get\_obj\_coef---retrieve objective coefficient or\\

 constant term}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 double glp_get_obj_coef(glp_prob *lp, int j);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_obj_coef| returns the objective coefficient

 at \verb|j|-th structural variable (column).

 If the parameter \verb|j| is 0, the routine returns the constant term

 (``shift'') of the objective function.

 \subsection{glp\_get\_num\_nz---retrieve number of constraint

 coefficients}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_num_nz(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_get_num_nz| returns the number of non-zero

 elements in the constraint matrix of the specified problem object.

 \subsection{glp\_get\_mat\_row---retrieve row of the constraint

 matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_mat_row(glp_prob *lp, int i, int ind[],

       double val[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_get_mat_row| scans (non-zero) elements of

 \verb|i|-th row of the constraint matrix of the specified problem object

 and stores their column indices and numeric values to locations

 \verb|ind[1]|, \dots, \verb|ind[len]| and \verb|val[1]|, \dots,

 \verb|val[len]|, respectively, where $0\leq{\tt len}\leq n$ is the

 number of elements in $i$-th row, $n$ is the number of columns.

 The parameter \verb|ind| and/or \verb|val| can be specified as

 \verb|NULL|, in which case corresponding information is not stored.

 \subsubsection*{Returns}

 The routine \verb|glp_get_mat_row| returns the length \verb|len|, i.e.

 the number of (non-zero) elements in \verb|i|-th row.

 \subsection{glp\_get\_mat\_col---retrieve column of the constraint\\

 matrix}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_get_mat_col(glp_prob *lp, int j, int ind[],

       double val[]);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_get_mat_col| scans (non-zero) elements of

 \verb|j|-th column of the constraint matrix of the specified problem

 object and stores their row indices and numeric values to locations

 \verb|ind[1]|, \dots, \verb|ind[len]| and \verb|val[1]|, \dots,

 \verb|val[len]|, respectively, where $0\leq{\tt len}\leq m$ is the

 number of elements in $j$-th column, $m$ is the number of rows.

 The parameter \verb|ind| and/or \verb|val| can be specified as

 \verb|NULL|, in which case corresponding information is not stored.

 \subsubsection*{Returns}

 The routine \verb|glp_get_mat_col| returns the length \verb|len|, i.e.

 the number of (non-zero) elements in \verb|j|-th column.

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \newpage

 \section{Row and column searching routines}

 \subsection{glp\_create\_index---create the name index}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_create_index(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_create_index| creates the name index for the

 specified problem object. The name index is an auxiliary data structure,

 which is intended to quickly (i.e. for logarithmic time) find rows and

 columns by their names.

 This routine can be called at any time. If the name index already

 exists, the routine does nothing.

 \subsection{glp\_find\_row---find row by its name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_find_row(glp_prob *lp, const char *name);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_find_row| returns the ordinal number of a row,

 which is assigned (by the routine \verb|glp_set_row_name|) the specified

 symbolic \verb|name|. If no such row exists, the routine returns 0.

 \subsection{glp\_find\_col---find column by its name}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 int glp_find_col(glp_prob *lp, const char *name);

 \end{verbatim}

 \subsubsection*{Returns}

 The routine \verb|glp_find_col| returns the ordinal number of a column,

 which is assigned (by the routine \verb|glp_set_col_name|) the specified

 symbolic \verb|name|. If no such column exists, the routine returns 0.

 \subsection{glp\_delete\_index---delete the name index}

 \subsubsection*{Synopsis}

 \begin{verbatim}

 void glp_delete_index(glp_prob *lp);

 \end{verbatim}

 \subsubsection*{Description}

 The routine \verb|glp_delete_index| deletes the name index previously

 created by the routine \verb|glp_create_index| and frees the memory

 allocated to this auxiliary data structure.

 This routine can be called at any time. If the name index does not

 exist, the routine does nothing.

 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

 \newpage

 \section{Problem scaling routines}

 \subsection{Background}

 In GLPK the {\it scaling} means a linear transformation applied to the

 constraint matrix to improve its numerical properties.\footnote{In many

 cases a proper scaling allows making the constraint matrix to be better

 conditioned, i.e. decreasing its condition number, that makes

 computations numerically more stable.}

 The main equality is the following:

 $$\widetilde{A}=RAS,\eqno(2.1)$$

 where $A=(a_{ij})$ is the original constraint matrix, $R=(r_{ii})>0$ is

 a diagonal matrix used to scale rows (constraints), $S=(s_{jj})>0$ is a

 diagonal matrix used to scale columns (variables), $\widetilde{A}$ is

 the scaled constraint matrix.

 From (2.1) it follows that in the {\it scaled} problem instance each

 original constraint coefficient $a_{ij}$ is replaced by corresponding

 scaled constraint coefficient:

 $$\widetilde{a}_{ij}=r_{ii}a_{ij}s_{jj}.\eqno(2.2)$$