%* glpk03.tex *%

\chapter{Utility API routines}

\section{Problem data reading/writing routines}

\subsection{glp\_read\_mps---read problem data in MPS format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_read_mps(glp_prob *lp, int fmt, const void *parm,

      const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_read_mps| reads problem data in MPS format from a

text file. (The MPS format is described in Appendix \ref{champs}, page

\pageref{champs}.)

The parameter \verb|fmt| specifies the MPS format version as follows:

\begin{tabular}{@{}ll}

\verb|GLP_MPS_DECK| & fixed (ancient) MPS format; \\

\verb|GLP_MPS_FILE| & free (modern) MPS format. \\

\end{tabular}

The parameter \verb|parm| is reserved for use in the future and must be

specified as \verb|NULL|.

The character string \verb|fname| specifies a name of the text file to

be read in. (If the file name ends with suffix `\verb|.gz|', the file is

assumed to be compressed, in which case the routine \verb|glp_read_mps|

decompresses it ``on the fly''.)

Note that before reading data the current content of the problem object

is completely erased with the routine \verb|glp_erase_prob|.

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_read_mps|

returns zero. Otherwise, it prints an error message and returns

non-zero.

\subsection{glp\_write\_mps---write problem data in MPS format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_write_mps(glp_prob *lp, int fmt, const void *parm,

      const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_write_mps| writes problem data in MPS format to a

text file. (The MPS format is described in Appendix \ref{champs}, page

\pageref{champs}.)

The parameter \verb|fmt| specifies the MPS format version as follows:

\begin{tabular}{@{}ll}

\verb|GLP_MPS_DECK| & fixed (ancient) MPS format; \\

\verb|GLP_MPS_FILE| & free (modern) MPS format. \\

\end{tabular}

The parameter \verb|parm| is reserved for use in the future and must be

specified as \verb|NULL|.

The character string \verb|fname| specifies a name of the text file to

be written out. (If the file name ends with suffix `\verb|.gz|', the

file is assumed to be compressed, in which case the routine

\verb|glp_write_mps| performs automatic compression on writing it.)

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_write_mps|

returns zero. Otherwise, it prints an error message and returns

non-zero.

\subsection{glp\_read\_lp---read problem data in CPLEX LP format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_read_lp(glp_prob *lp, const void *parm,

      const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_read_lp| reads problem data in CPLEX LP format

from a text file. (The CPLEX LP format is described in Appendix

\ref{chacplex}, page \pageref{chacplex}.)

The parameter \verb|parm| is reserved for use in the future and must be

specified as \verb|NULL|.

The character string \verb|fname| specifies a name of the text file to

be read in. (If the file name ends with suffix `\verb|.gz|', the file is

assumed to be compressed, in which case the routine \verb|glp_read_lp|

decompresses it ``on the fly''.)

Note that before reading data the current content of the problem object

is completely erased with the routine \verb|glp_erase_prob|.

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_read_lp| returns

zero. Otherwise, it prints an error message and returns non-zero.

\subsection{glp\_write\_lp---write problem data in CPLEX LP format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_write_lp(glp_prob *lp, const void *parm,

      const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_write_lp| writes problem data in CPLEX LP format

to a text file. (The CPLEX LP format is described in Appendix

\ref{chacplex}, page \pageref{chacplex}.)

The parameter \verb|parm| is reserved for use in the future and must be

specified as \verb|NULL|.

The character string \verb|fname| specifies a name of the text file to

be written out. (If the file name ends with suffix `\verb|.gz|', the

file is assumed to be compressed, in which case the routine

\verb|glp_write_lp| performs automatic compression on writing it.)

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_write_lp|

returns zero. Otherwise, it prints an error message and returns

non-zero.

\subsection{glp\_read\_prob---read problem data in GLPK format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_read_prob(glp_prob *P, int flags, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_read_prob| reads problem data in the GLPK LP/MIP

format from a text file. (For description of the GLPK LP/MIP format see

below.)

The parameter \verb|flags| is reserved for use in the future and should

be specified as zero.

The character string \verb|fname| specifies a name of the text file to

be read in. (If the file name ends with suffix `\verb|.gz|', the file

is assumed to be compressed, in which case the routine

\verb|glp_read_prob| decompresses it ``on the fly''.)

Note that before reading data the current content of the problem object

is completely erased with the routine \verb|glp_erase_prob|.

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_read_prob|

returns zero. Otherwise, it prints an error message and returns

non-zero.

\subsubsection*{GLPK LP/MIP format}

The GLPK LP/MIP format is a DIMACS-like format.\footnote{The DIMACS

formats were developed by the Center for Discrete Mathematics and

Theoretical Computer Science (DIMACS) to facilitate exchange of problem

data. For details see: {\tt <http://dimacs.rutgers.edu/Challenges/>}. }

The file in this format is a plain ASCII text file containing lines of

several types described below. A line is terminated with the end-of-line

character. Fields in each line are separated by at least one blank

space. Each line begins with a one-character designator to identify the

line type.

The first line of the data file must be the problem line (except

optional comment lines, which may precede the problem line). The last

line of the data file must be the end line. Other lines may follow in

arbitrary order, however, duplicate lines are not allowed.

\paragraph{Comment lines.} Comment lines give human-readable

information about the data file and are ignored by GLPK routines.

Comment lines can appear anywhere in the data file. Each comment line

begins with the lower-case character \verb|c|.

\begin{verbatim}

   c This is an example of comment line

\end{verbatim}

\paragraph{Problem line.} There must be exactly one problem line in the

data file. This line must appear before any other lines except comment

lines and has the following format:

\begin{verbatim}

   p CLASS DIR ROWS COLS NONZ

\end{verbatim}

The lower-case letter \verb|p| specifies that this is the problem line.

The \verb|CLASS| field defines the problem class and can contain either

the keyword \verb|lp| (that means linear programming problem) or

\verb|mip| (that means mixed integer programming problem).

The \verb|DIR| field defines the optimization direction (that is, the

objective function sense) and can contain either the keyword \verb|min|

(that means minimization) or \verb|max| (that means maximization).

The \verb|ROWS|, \verb|COLS|, and \verb|NONZ| fields contain

non-negative integer values specifying, respectively, the number of

rows (constraints), columns (variables), and non-zero constraint

coefficients in the problem instance. Note that \verb|NONZ| value does

not account objective coefficients.

\paragraph{Row descriptors.} There must be at most one row descriptor

line in the data file for each row (constraint). This line has one of

the following formats:

\begin{verbatim}

   i ROW f

   i ROW l RHS

   i ROW u RHS

   i ROW d RHS1 RHS2

   i ROW s RHS

\end{verbatim}

The lower-case letter \verb|i| specifies that this is the row

descriptor line.

The \verb|ROW| field specifies the row ordinal number, an integer

between 1 and $m$, where $m$ is the number of rows in the problem

instance.

The next lower-case letter specifies the row type as follows:

\verb|f| --- free (unbounded) row: $-\infty<\sum a_jx_j<+\infty$;

\verb|l| --- inequality constraint of `$\geq$' type:

$\sum a_jx_j\geq b$;

\verb|u| --- inequality constraint of `$\leq$' type:

$\sum a_jx_j\leq b$;

\verb|d| --- double-sided inequality constraint:

$b_1\leq\sum a_jx_j\leq b_2$;

\verb|s| --- equality constraint: $\sum a_jx_j=b$.

The \verb|RHS| field contains a floaing-point value specifying the

row right-hand side. The \verb|RHS1| and \verb|RHS2| fields contain

floating-point values specifying, respectively, the lower and upper

right-hand sides for the double-sided row.

If for some row its descriptor line does not appear in the data file,

by default that row is assumed to be an equality constraint with zero

right-hand side.

\paragraph{Column descriptors.} There must be at most one column

descriptor line in the data file for each column (variable). This line

has one of the following formats depending on the problem class

specified in the problem line:

\bigskip

\begin{tabular}{@{}l@{\hspace*{40pt}}l}

LP class & MIP class \\

\hline

\verb|j COL f|           & \verb|j COL KIND f|           \\

\verb|j COL l BND|       & \verb|j COL KIND l BND|       \\

\verb|j COL u BND|       & \verb|j COL KIND u BND|       \\

\verb|j COL d BND1 BND2| & \verb|j COL KIND d BND1 BND2| \\

\verb|j COL s BND|       & \verb|j COL KIND s BND|       \\

\end{tabular}

\bigskip

The lower-case letter \verb|j| specifies that this is the column

descriptor line.

The \verb|COL| field specifies the column ordinal number, an integer

between 1 and $n$, where $n$ is the number of columns in the problem

instance.

The \verb|KIND| field is used only for MIP problems and specifies the

column kind as follows:

\verb|c| --- continuous column;

\verb|i| --- integer column;

\verb|b| --- binary column (in this case all remaining fields must be

omitted).

The next lower-case letter specifies the column type as follows:

\verb|f| --- free (unbounded) column: $-\infty<x<+\infty$;

\verb|l| --- column with lower bound: $x\geq l$;

\verb|u| --- column with upper bound: $x\leq u$;

\verb|d| --- double-bounded column: $l\leq x\leq u$;

\verb|s| --- fixed column: $x=s$.

The \verb|BND| field contains a floating-point value that specifies the

column bound. The \verb|BND1| and \verb|BND2| fields contain

floating-point values specifying, respectively, the lower and upper

bounds for the double-bounded column.

If for some column its descriptor line does not appear in the file, by

default that column is assumed to be non-negative (in case of LP class)

or binary (in case of MIP class).

\paragraph{Coefficient descriptors.} There must be exactly one

coefficient descriptor line in the data file for each non-zero

objective or constraint coefficient. This line has the following format:

\begin{verbatim}

   a ROW COL VAL

\end{verbatim}

The lower-case letter \verb|a| specifies that this is the coefficient

descriptor line.

For objective coefficients the \verb|ROW| field must contain 0. For

constraint coefficients the \verb|ROW| field specifies the row ordinal

number, an integer between 1 and $m$, where $m$ is the number of rows

in the problem instance.

The \verb|COL| field specifies the column ordinal number, an integer

between 1 and $n$, where $n$ is the number of columns in the problem

instance.

If both the \verb|ROW| and \verb|COL| fields contain 0, the line

specifies the constant term (``shift'') of the objective function

rather than objective coefficient.

The \verb|VAL| field contains a floating-point coefficient value (it is

allowed to specify zero value in this field).

The number of constraint coefficient descriptor lines must be exactly

the same as specified in the field \verb|NONZ| of the problem line.

\paragraph{Symbolic name descriptors.} There must be at most one

symbolic name descriptor line for the problem instance, objective

function, each row (constraint), and each column (variable). This line

has one of the following formats:

\begin{verbatim}

   n p NAME

   n z NAME

   n i ROW NAME

   n j COL NAME

\end{verbatim}

The lower-case letter \verb|n| specifies that this is the symbolic name

descriptor line.

The next lower-case letter specifies which object should be assigned a

symbolic name:

\verb|p| --- problem instance;

\verb|z| --- objective function;

\verb|i| --- row (constraint);

\verb|j| --- column (variable).

The \verb|ROW| field specifies the row ordinal number, an integer

between 1 and $m$, where $m$ is the number of rows in the problem

instance.

The \verb|COL| field specifies the column ordinal number, an integer

between 1 and $n$, where $n$ is the number of columns in the problem

instance.

The \verb|NAME| field contains the symbolic name, a sequence from 1 to

255 arbitrary graphic ASCII characters, assigned to corresponding

object.

\paragraph{End line.} There must be exactly one end line in the data

file. This line must appear last in the file and has the following

format:

\begin{verbatim}

   e

\end{verbatim}

The lower-case letter \verb|e| specifies that this is the end line.

Anything that follows the end line is ignored by GLPK routines.

\subsubsection*{Example of data file in GLPK LP/MIP format}

The following example of a data file in GLPK LP/MIP format specifies

the same LP problem as in Subsection ``Example of MPS file''.

\begin{center}

\footnotesize\tt

\begin{tabular}{l@{\hspace*{50pt}}}

p lp min 8 7 48   \\

n p PLAN          \\

n z VALUE         \\

i 1 f             \\

n i 1 VALUE       \\

i 2 s 2000        \\

n i 2 YIELD       \\

i 3 u 60          \\

n i 3 FE          \\

i 4 u 100         \\

n i 4 CU          \\

i 5 u 40          \\

n i 5 MN          \\

i 6 u 30          \\

n i 6 MG          \\

i 7 l 1500        \\

n i 7 AL          \\

i 8 d 250 300     \\

n i 8 SI          \\

j 1 d 0 200       \\

n j 1 BIN1        \\

j 2 d 0 2500      \\

n j 2 BIN2        \\

j 3 d 400 800     \\

n j 3 BIN3        \\

j 4 d 100 700     \\

n j 4 BIN4        \\

j 5 d 0 1500      \\

n j 5 BIN5        \\

n j 6 ALUM        \\

n j 7 SILICON     \\

a 0 1 0.03        \\

a 0 2 0.08        \\

a 0 3 0.17        \\

a 0 4 0.12        \\

a 0 5 0.15        \\

a 0 6 0.21        \\

a 0 7 0.38        \\

a 1 1 0.03        \\

a 1 2 0.08        \\

a 1 3 0.17        \\

a 1 4 0.12        \\

a 1 5 0.15        \\

a 1 6 0.21        \\

\end{tabular}

\begin{tabular}{|@{\hspace*{80pt}}l}

a 1 7 0.38        \\

a 2 1 1           \\

a 2 2 1           \\

a 2 3 1           \\

a 2 4 1           \\

a 2 5 1           \\

a 2 6 1           \\

a 2 7 1           \\

a 3 1 0.15        \\

a 3 2 0.04        \\

a 3 3 0.02        \\

a 3 4 0.04        \\

a 3 5 0.02        \\

a 3 6 0.01        \\

a 3 7 0.03        \\

a 4 1 0.03        \\

a 4 2 0.05        \\

a 4 3 0.08        \\

a 4 4 0.02        \\

a 4 5 0.06        \\

a 4 6 0.01        \\

a 5 1 0.02        \\

a 5 2 0.04        \\

a 5 3 0.01        \\

a 5 4 0.02        \\

a 5 5 0.02        \\

a 6 1 0.02        \\

a 6 2 0.03        \\

a 6 5 0.01        \\

a 7 1 0.7         \\

a 7 2 0.75        \\

a 7 3 0.8         \\

a 7 4 0.75        \\

a 7 5 0.8         \\

a 7 6 0.97        \\

a 8 1 0.02        \\

a 8 2 0.06        \\

a 8 3 0.08        \\

a 8 4 0.12        \\

a 8 5 0.02        \\

a 8 6 0.01        \\

a 8 7 0.97        \\

e o f             \\

\\

\end{tabular}

\end{center}

\newpage

\subsection{glp\_write\_prob---write problem data in GLPK format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_write_prob(glp_prob *P, int flags, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_write_prob| writes problem data in the GLPK

LP/MIP format to a text file. (For description of the GLPK LP/MIP

format see Subsection ``Read problem data in GLPK format''.)

The parameter \verb|flags| is reserved for use in the future and should

be specified as zero.

The character string \verb|fname| specifies a name of the text file to

be written out. (If the file name ends with suffix `\verb|.gz|', the

file is assumed to be compressed, in which case the routine

\verb|glp_write_prob| performs automatic compression on writing it.)

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_read_prob|

returns zero. Otherwise, it prints an error message and returns

non-zero.

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

\newpage

\section{Routines for processing MathProg models}

\subsection{Introduction}

GLPK supports the {\it GNU MathProg modeling language}.\footnote{The

GNU MathProg modeling language is a subset of the AMPL language. For

its detailed description see the document ``Modeling Language GNU

MathProg: Language Reference'' included in the GLPK distribution.}

As a rule, models written in MathProg are solved with the GLPK LP/MIP

stand-alone solver \verb|glpsol| (see Appendix D) and do not need any

programming with API routines. However, for various reasons the user

may need to process MathProg models directly in his/her application

program, in which case he/she may use API routines described in this

section. These routines provide an interface to the {\it MathProg

translator}, a component of GLPK, which translates MathProg models into

an internal code and then interprets (executes) this code.

The processing of a model written in GNU MathProg includes several

steps, which should be performed in the following order:

\begin{enumerate}

\item{\it Allocating the workspace.}

The translator allocates the workspace, an internal data structure used

on all subsequent steps.

\item{\it Reading model section.} The translator reads model section

and, optionally, data section from a specified text file and translates

them into the internal code. If necessary, on this step data section

may be ignored.

\item{\it Reading data section(s).} The translator reads one or more

data sections from specified text file(s) and translates them into the

internal code.

\item{\it Generating the model.} The translator executes the internal

code to evaluate the content of the model objects such as sets,

parameters, variables, constraints, and objectives. On this step the

execution is suspended at the solve statement.

\item {\it Building the problem object.} The translator obtains all

necessary information from the workspace and builds the standard

problem object (that is, the program object of type \verb|glp_prob|).

\item{\it Solving the problem.} On this step the problem object built

on the previous step is passed to a solver, which solves the problem

instance and stores its solution back to the problem object.

\item{\it Postsolving the model.} The translator copies the solution

from the problem object to the workspace and then executes the internal

code from the solve statement to the end of the model. (If model has

no solve statement, the translator does nothing on this step.)

\item{\it Freeing the workspace.} The translator frees all the memory

allocated to the workspace.

\end{enumerate}

Note that the MathProg translator performs no error correction, so if

any of steps 2 to 7 fails (due to errors in the model), the application

program should terminate processing and go to step 8.

\subsubsection*{Example 1}

In this example the program reads model and data sections from input

file \verb|egypt.mod|\footnote{This is an example model included in

the GLPK distribution.} and writes the model to output file

\verb|egypt.mps| in free MPS format (see Appendix B). No solution is

performed.

\begin{small}

\begin{verbatim}

/* mplsamp1.c */

#include <stdio.h>

#include <stdlib.h>

#include <glpk.h>

int main(void)

{     glp_prob *lp;

      glp_tran *tran;

      int ret;

      lp = glp_create_prob();

      tran = glp_mpl_alloc_wksp();

      ret = glp_mpl_read_model(tran, "egypt.mod", 0);

      if (ret != 0)

      {  fprintf(stderr, "Error on translating model\n");

         goto skip;

      }

      ret = glp_mpl_generate(tran, NULL);

      if (ret != 0)

      {  fprintf(stderr, "Error on generating model\n");

         goto skip;

      }

      glp_mpl_build_prob(tran, lp);

      ret = glp_write_mps(lp, GLP_MPS_FILE, NULL, "egypt.mps");

      if (ret != 0)

         fprintf(stderr, "Error on writing MPS file\n");

skip: glp_mpl_free_wksp(tran);

      glp_delete_prob(lp);

      return 0;

}

/* eof */

\end{verbatim}

\end{small}

\subsubsection*{Example 2}

In this example the program reads model section from file

\verb|sudoku.mod|\footnote{This is an example model which is included

in the GLPK distribution along with alternative data file

{\tt sudoku.dat}.} ignoring data section in this file, reads alternative

data section from file \verb|sudoku.dat|, solves the problem instance

and passes the solution found back to the model.

\begin{small}

\begin{verbatim}

/* mplsamp2.c */

#include <stdio.h>

#include <stdlib.h>

#include <glpk.h>

int main(void)

{     glp_prob *mip;

      glp_tran *tran;

      int ret;

      mip = glp_create_prob();

      tran = glp_mpl_alloc_wksp();

      ret = glp_mpl_read_model(tran, "sudoku.mod", 1);

      if (ret != 0)

      {  fprintf(stderr, "Error on translating model\n");

         goto skip;

      }

      ret = glp_mpl_read_data(tran, "sudoku.dat");

      if (ret != 0)

      {  fprintf(stderr, "Error on translating data\n");

         goto skip;

      }

      ret = glp_mpl_generate(tran, NULL);

      if (ret != 0)

      {  fprintf(stderr, "Error on generating model\n");

         goto skip;

      }

      glp_mpl_build_prob(tran, mip);

      glp_simplex(mip, NULL);

      glp_intopt(mip, NULL);

      ret = glp_mpl_postsolve(tran, mip, GLP_MIP);

      if (ret != 0)

         fprintf(stderr, "Error on postsolving model\n");

skip: glp_mpl_free_wksp(tran);

      glp_delete_prob(mip);

      return 0;

}

/* eof */

\end{verbatim}

\end{small}

\subsection{glp\_mpl\_alloc\_wksp---allocate the translator workspace}

\subsubsection*{Synopsis}

\begin{verbatim}

glp_tran *glp_mpl_alloc_wksp(void);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_alloc_wksp| allocates the MathProg translator

work\-space. (Note that multiple instances of the workspace may be

allocated, if necessary.)

\subsubsection*{Returns}

The routine returns a pointer to the workspace, which should be used in

all subsequent operations.

\subsection{glp\_mpl\_read\_model---read and translate model section}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_mpl_read_model(glp_tran *tran, const char *fname,

      int skip);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_read_model| reads model section and,

optionally, data section, which may follow the model section, from a

text file, whose name is the character string \verb|fname|, performs

translation of model statements and data blocks, and stores all the

information in the workspace.

The parameter \verb|skip| is a flag. If the input file contains the

data section and this flag is non-zero, the data section is not read as

if there were no data section and a warning message is printed. This

allows reading data section(s) from other file(s).

\subsubsection*{Returns}

If the operation is successful, the routine returns zero. Otherwise

the routine prints an error message and returns non-zero.

\subsection{glp\_mpl\_read\_data---read and translate data section}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_mpl_read_data(glp_tran *tran, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_read_data| reads data section from a text

file, whose name is the character string \verb|fname|, performs

translation of data blocks, and stores the data read in the translator

workspace. If necessary, this routine may be called more than once.

\subsubsection*{Returns}

If the operation is successful, the routine returns zero. Otherwise

the routine prints an error message and returns non-zero.

\subsection{glp\_mpl\_generate---generate the model}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_mpl_generate(glp_tran *tran, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_generate| generates the model using its

description stored in the translator workspace. This operation means

generating all variables, constraints, and objectives, executing check

and display statements, which precede the solve statement (if it is

presented).

The character string \verb|fname| specifies the name of an output text

file, to which output produced by display statements should be written.

If \verb|fname| is \verb|NULL|, the output is sent to the terminal.

\subsubsection*{Returns}

If the operation is successful, the routine returns zero. Otherwise

the routine prints an error message and returns non-zero.

\subsection{glp\_mpl\_build\_prob---build problem instance from the

model}

\subsubsection*{Synopsis}

\begin{verbatim}

void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_build_prob| obtains all necessary information

from the translator workspace and stores it in the specified problem

object \verb|prob|. Note that before building the current content of

the problem object is erased with the routine \verb|glp_erase_prob|.

\subsection{glp\_mpl\_postsolve---postsolve the model}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob,

      int sol);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_postsolve| copies the solution from the

specified problem object \verb|prob| to the translator workspace and

then executes all the remaining model statements, which follow the

solve statement.

The parameter \verb|sol| specifies which solution should be copied

from the problem object to the workspace as follows:

\begin{tabular}{@{}ll}

\verb|GLP_SOL| & basic solution; \\

\verb|GLP_IPT| & interior-point solution; \\

\verb|GLP_MIP| & mixed integer solution. \\

\end{tabular}

\subsubsection*{Returns}

If the operation is successful, the routine returns zero. Otherwise

the routine prints an error message and returns non-zero.

\subsection{glp\_mpl\_free\_wksp---free the translator workspace}

\subsubsection*{Synopsis}

\begin{verbatim}

void glp_mpl_free_wksp(glp_tran *tran);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mpl_free_wksp| frees all the memory allocated to

the translator workspace. It also frees all other resources, which are

still used by the translator.

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

\newpage

\section{Problem solution reading/writing routines}

\subsection{glp\_print\_sol---write basic solution in printable format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_print_sol(glp_prob *lp, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_print_sol writes| the current basic solution of

an LP problem, which is specified by the pointer \verb|lp|, to a text

file, whose name is the character string \verb|fname|, in printable

format.

Information reported by the routine \verb|glp_print_sol| is intended

mainly for visual analysis.

\subsubsection*{Returns}

If no errors occurred, the routine returns zero. Otherwise the routine

prints an error message and returns non-zero.

\subsection{glp\_read\_sol---read basic solution from text file}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_read_sol(glp_prob *lp, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_read_sol| reads basic solution from a text file

whose name is specified by the parameter \verb|fname| into the problem

object.

For the file format see description of the routine \verb|glp_write_sol|.

\subsubsection*{Returns}

On success the routine returns zero, otherwise non-zero.

\newpage

\subsection{glp\_write\_sol---write basic solution to text file}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_write_sol(glp_prob *lp, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_write_sol| writes the current basic solution to a

text file whose name is specified by the parameter \verb|fname|. This

file can be read back with the routine \verb|glp_read_sol|.

\subsubsection*{Returns}

On success the routine returns zero, otherwise non-zero.

\subsubsection*{File format}

The file created by the routine \verb|glp_write_sol| is a plain text

file, which contains the following information:

\begin{verbatim}

   m n

   p_stat d_stat obj_val

   r_stat[1] r_prim[1] r_dual[1]

   . . .

   r_stat[m] r_prim[m] r_dual[m]

   c_stat[1] c_prim[1] c_dual[1]

   . . .

   c_stat[n] c_prim[n] c_dual[n]

\end{verbatim}

\noindent

where:

\noindent

$m$ is the number of rows (auxiliary variables);

\noindent

$n$ is the number of columns (structural variables);

\noindent

\verb|p_stat| is the primal status of the basic solution

(\verb|GLP_UNDEF| = 1, \verb|GLP_FEAS| = 2, \verb|GLP_INFEAS| = 3, or

\verb|GLP_NOFEAS| = 4);

\noindent

\verb|d_stat| is the dual status of the basic solution

(\verb|GLP_UNDEF| = 1, \verb|GLP_FEAS| = 2, \verb|GLP_INFEAS| = 3, or

\verb|GLP_NOFEAS| = 4);

\noindent

\verb|obj_val| is the objective value;

\noindent

\verb|r_stat[i]|, $i=1,\dots,m$, is the status of $i$-th row

(\verb|GLP_BS| = 1, \verb|GLP_NL| = 2, \verb|GLP_NU| = 3,

\verb|GLP_NF| = 4, or \verb|GLP_NS| = 5);

\noindent

\verb|r_prim[i]|, $i=1,\dots,m$, is the primal value of $i$-th row;

\noindent

\verb|r_dual[i]|, $i=1,\dots,m$, is the dual value of $i$-th row;

\noindent

\verb|c_stat[j]|, $j=1,\dots,n$, is the status of $j$-th column

(\verb|GLP_BS| = 1, \verb|GLP_NL| = 2, \verb|GLP_NU| = 3,

\verb|GLP_NF| = 4, or \verb|GLP_NS| = 5);

\noindent

\verb|c_prim[j]|, $j=1,\dots,n$, is the primal value of $j$-th column;

\noindent

\verb|c_dual[j]|, $j=1,\dots,n$, is the dual value of $j$-th column.

\subsection{glp\_print\_ipt---write interior-point solution in

printable format}

\subsubsection*{Synopsis}

\begin{verbatim}

int glp_print_ipt(glp_prob *lp, const char *fname);

\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_print_ipt| writes the current interior point

solution  of an LP problem, which the parameter \verb|lp| points to, to

a text file, whose name is the character string \verb|fname|, in

printable format.

Information reported by the routine \verb|glp_print_ipt| is intended

mainly for visual analysis.

\subsubsection*{Returns}

If no errors occurred, the routine returns zero. Otherwise the routine

prints an error message and returns non-zero.

\subsection{glp\_read\_ipt---read interior-point solution from text

file}