%* 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[],