%* glpk06.tex *%

\chapter{Miscellaneous API Routines}

\section{GLPK environment routines}

\subsection{glp\_long---64-bit integer data type}

Some GLPK API routines use 64-bit integer data type, which is declared
in the header \verb|glpk.h| as follows:

\begin{verbatim}
typedef struct { int lo, hi; } glp_long;
\end{verbatim}

\noindent
where \verb|lo| contains low 32 bits, and \verb|hi| contains high 32
bits of 64-bit integer value.\footnote{GLPK conforms to ILP32, LLP64,
and LP64 programming models, where the built-in type {\tt int}
corresponds to 32-bit integers.}

\subsection{glp\_init\_env---initialize GLPK environment}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_init_env(void);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_init_env| initializes the GLPK environment.
Normally the application program does not need to call this routine,
because it is called automatically on the first call to any API routine.

\newpage

\subsubsection*{Returns}

The routine \verb|glp_init_env| returns one of the following codes:

\noindent
0 --- initialization successful;

\noindent
1 --- environment is already initialized;

\noindent
2 --- initialization failed (insufficient memory);

\noindent
3 --- initialization failed (unsupported programming model).

\subsection{glp\_version---determine library version}

\subsubsection*{Synopsis}

\begin{verbatim}
const char *glp_version(void);
\end{verbatim}

\subsubsection*{Returns}

The routine \verb|glp_version| returns a pointer to a null-terminated
character string, which specifies the version of the GLPK library in
the form \verb|"X.Y"|, where `\verb|X|' is the major version number, and
`\verb|Y|' is the minor version number, for example, \verb|"4.16"|.

\subsubsection*{Example}

\begin{footnotesize}
\begin{verbatim}
printf("GLPK version is %s\n", glp_version());
\end{verbatim}
\end{footnotesize}

\subsection{glp\_free\_env---free GLPK environment}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_free_env(void);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_free_env| frees all resources used by GLPK
routines (memory blocks, etc.) which are currently still in use.

Normally the application program does not need to call this routine,
because GLPK routines always free all unused resources. However, if
the application program even has deleted all problem objects, there
will be several memory blocks still allocated for the internal library
needs. For some reasons the application program may want GLPK to free
this memory, in which case it should call \verb|glp_free_env|.

Note that a call to \verb|glp_free_env| invalidates all problem objects
which still exist.

\subsubsection*{Returns}

The routine \verb|glp_free_env| returns one of the following codes:

\noindent
0 --- termination successful;

\noindent
1 --- environment is inactive (was not initialized).

\subsection{glp\_printf---write formatted output to terminal}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_printf(const char *fmt, ...);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_printf| uses the format control string
\verb|fmt| to format its parameters and writes the formatted output to
the terminal.

This routine is a replacement of the standard C function
\verb|printf| and used by all GLPK routines to perform terminal
output. The application program may use \verb|glp_printf| for the same
purpose that allows controlling its terminal output with the routines
\verb|glp_term_out| and \verb|glp_term_hook|.

\subsection{glp\_vprintf---write formatted output to terminal}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_vprintf(const char *fmt, va_list arg);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_vprintf| uses the format control string
\verb|fmt| to format its parameters specified by the list \verb|arg|
and writes the formatted output to the terminal.

This routine is a replacement of the standard C function
\verb|vprintf| and used by all GLPK routines to perform terminal
output. The application program may use \verb|glp_vprintf| for the same
purpose that allows controlling its terminal output with the routines
\verb|glp_term_out| and \verb|glp_term_hook|.

\newpage

\subsection{glp\_term\_out---enable/disable terminal output}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_term_out(int flag);
\end{verbatim}

\subsubsection*{Description}

Depending on the parameter flag the routine \verb|glp_term_out| enables
or disables terminal output performed by glpk routines:

\verb|GLP_ON | --- enable terminal output;

\verb|GLP_OFF| --- disable terminal output.

\subsubsection*{Returns}

The routine \verb|glp_term_out| returns the previous value of the
terminal output flag (\verb|GLP_ON| or \verb|GLP_OFF|).

\subsection{glp\_term\_hook---intercept terminal output}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_term_hook(int (*func)(void *info, const char *s),
      void *info);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_term_hook| installs the user-defined hook routine
to intercept all terminal output performed by GLPK routines.

%This feature can be used to redirect the terminal output to other
%destination, for example, to a file or a text window.

The parameter {\it func} specifies the user-defined hook routine. It is
called from an internal printing routine, which passes to it two
parameters: {\it info} and {\it s}. The parameter {\it info} is a
transit pointer specified in corresponding call to the routine
\verb|glp_term_hook|; it may be used to pass some additional information
to the hook routine. The parameter {\it s} is a pointer to the null
terminated character string, which is intended to be written to the
terminal. If the hook routine returns zero, the printing routine writes
the string {\it s} to the terminal in a usual way; otherwise, if the
hook routine returns non-zero, no terminal output is performed.

To uninstall the hook routine both parameters {\it func} and {\it info}
should be specified as \verb|NULL|.

\newpage

\subsubsection*{Example}

\begin{footnotesize}
\begin{verbatim}
static int hook(void *info, const char *s)
{     FILE *foo = info;
      fputs(s, foo);
      return 1;
}

int main(void)
{     FILE *foo;
      . . .
      /* redirect terminal output */
      glp_term_hook(hook, foo);
      . . .
      /* resume terminal output */
      glp_term_hook(NULL, NULL);
      . . .
}
\end{verbatim}
\end{footnotesize}

\subsection{glp\_open\_tee---start copying terminal output}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_open_tee(const char *fname);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_open_tee| starts copying all the terminal output
to an output text file, whose name is specified by the character string
\verb|fname|.

\subsubsection*{Returns}

The routine \verb|glp_open_tee| returns one of the following codes:

\noindent
0 --- operation successful;

\noindent
1 --- copying terminal output is already active;

\noindent
2 --- unable to create output file.

\newpage

\subsection{glp\_close\_tee---stop copying terminal output}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_close_tee(void);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_close_tee| stops copying the terminal output to
the output text file previously open by the routine \verb|glp_open_tee|
closing that file.

\subsubsection*{Returns}

The routine \verb|glp_close_tee| returns one of the following codes:

\noindent
0 --- operation successful;

\noindent
1 --- copying terminal output was not started.

\subsection{glp\_error---display error message and terminate execution}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_error(const char *fmt, ...);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_error| (implemented as a macro) formats its
parameters using the format control string \verb|fmt|, writes the
formatted message to the terminal, and then abnormally terminates the
program.

\subsection{glp\_assert---check logical condition}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_assert(int expr);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_assert| (implemented as a macro) checks
a logical condition specified by the expression \verb|expr|. If the
condition is true (non-zero), the routine does nothing; otherwise, if
the condition is false (zero), the routine prints an error message and
abnormally terminates the program.

This routine is a replacement of the standard C function \verb|assert|
and used by all GLPK routines to check program logic. The application
program may use \verb|glp_assert| for the same purpose.

\subsection{glp\_error\_hook---install hook to intercept abnormal
termination}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_error_hook(void (*func)(void *info), void *info);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_error_hook| installs a user-defined hook routine
to intercept abnormal termination.

The parameter \verb|func| specifies the user-defined hook routine. It
is called from the routine \verb|glp_error| before the latter calls the
abort function to abnormally terminate the application program because
of fatal error. The parameter \verb|info| is a transit pointer,
specified in the corresponding call to the routine
\verb|glp_error_hook|; it may be used to pass some information to the
hook routine.

To uninstall the hook routine the parameters \verb|func| and \verb|info|
should be specified as \verb|NULL|.

\subsubsection*{Usage note}

If the hook routine returns, the application program is abnormally
terminated. To prevent abnormal termnation the hook routine may perform
a global jump using the standard function \verb|longjmp|, in which case
the application program {\it must} call the routine \verb|glp_free_env|.

\subsection{glp\_malloc---allocate memory block}

\subsubsection*{Synopsis}

\begin{verbatim}
void *glp_malloc(int size);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_malloc| dynamically allocates a memory block of
\verb|size| bytes long. Should note that:

1) the parameter \verb|size| must be positive;

2) being allocated the memory block contains arbitrary data, that is,
it is {\it not} initialized by binary zeros;

3) if the block cannot be allocated due to insufficient memory, the
routine prints an error message and abnormally terminates the program.

This routine is a replacement of the standard C function \verb|malloc|
and used by all GLPK routines for dynamic memory allocation. The
application program may use \verb|glp_malloc| for the same purpose.

\subsubsection*{Returns}

The routine \verb|glp_malloc| returns a pointer to the memory block
allocated. To free this block the routine \verb|glp_free| (not the
standard C function \verb|free|!) must be used.

\subsection{glp\_calloc---allocate memory block}

\subsubsection*{Synopsis}

\begin{verbatim}
void *glp_calloc(int n, int size);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_calloc| dynamically allocates a memory block of
\verb|n|$\times$\verb|size| bytes long. Should note that:

1) both parameters \verb|n| and \verb|size| must be positive;

2) being allocated the memory block contains arbitrary data, that is,
it is {\it not} initialized by binary zeros;

3) if the block cannot be allocated due to insufficient memory, the
routine prints an error message and abnormally terminates the program.

This routine is a replacement of the standard C function \verb|calloc|
(with exception that the block is not cleaned) and used by all GLPK
routines for dynamic memory allocation. The application program may use
\verb|glp_calloc| for the same purpose.

\subsubsection*{Returns}

The routine \verb|glp_calloc| returns a pointer to the memory block
allocated. To free this block the routine \verb|glp_free| (not the
standard C function \verb|free|!) must be used.

\subsection{glp\_free---free memory block}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_free(void *ptr);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_free| frees (deallocates) a memory block pointed
to by \verb|ptr|, which was previously allocated by the routine
\verb|glp_malloc| or \verb|glp_calloc|. Note that the pointer \verb|ptr|
must valid and must not be \verb|NULL|.

This routine is a replacement of the standard C function \verb|free|
and used by all GLPK routines for dynamic memory allocation. The
application program may use \verb|glp_free| for the same purpose.

\subsection{glp\_mem\_usage---get memory usage information}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_mem_usage(int *count, int *cpeak, glp_long *total,
      glp_long *tpeak);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mem_usage| reports some information about
utilization of the memory by the routines \verb|glp_malloc|,
\verb|glp_calloc|, and \verb|glp_free|. Information is stored to
locations specified by corresponding parameters (see below). Any
parameter can be specified as \verb|NULL|, in which case corresponding
information is not stored.

\verb|*count| is the number of currently allocated memory blocks.

\verb|*cpeak| is the peak value of \verb|*count| reached since the
initialization of the GLPK library environment.

\verb|*total| is the total amount, in bytes, of currently allocated
memory blocks.

\verb|*tpeak| is the peak value of \verb|*total| reached since the
initialization of the GLPK library envirionment.

\subsubsection*{Example}

\begin{footnotesize}
\begin{verbatim}
glp_mem_usage(&count, NULL, NULL, NULL);
printf("%d memory block(s) are still allocated\n", count);
\end{verbatim}
\end{footnotesize}

\subsection{glp\_mem\_limit---set memory usage limit}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_mem_limit(int limit);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_mem_limit| limits the amount of memory available
for dynamic allocation (with the routines \verb|glp_malloc| and
\verb|glp_calloc|) to \verb|limit| megabytes.

\subsection{glp\_time---determine current universal time}

\subsubsection*{Synopsis}

\begin{verbatim}
glp_long glp_time(void);
\end{verbatim}

\subsection*{Returns}

The routine \verb|glp_time| returns the current universal time (UTC),
in milliseconds, elapsed since 00:00:00 GMT January 1, 1970.

\subsection{glp\_difftime---compute difference between two time values}

\subsubsection*{Synopsis}

\begin{verbatim}
double glp_difftime(glp_long t1, glp_long t0);
\end{verbatim}

\subsection*{Returns}

The routine \verb|glp_difftime| returns the difference between two time
values \verb|t1| and \verb|t0|, expressed in seconds.

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

\newpage

\section{Plain data file reading routines}

\subsection{Introduction}

On developing simple applications to solve optimization problems it is
often needed to read data from plain text files. To do this the standard
C function \verb|fscanf| may be used, however, it is not convenient; for
example, if it scans an integer number according to the format
specification `\verb|%d|', and that number is coded incorrectly,
no diagnostics is provided.

This section describes a set of GLPK API routines, which may be used in
application programs to simplify reading data from plain text files.

\subsubsection*{Example 1}

The following main program reads ten integer numbers from plain text
file \verb|data.txt| and prints their sum.

\begin{footnotesize}
\begin{verbatim}
/* sdfsamp1.c */

#include <stdio.h>
#include <stdlib.h>
#include <glpk.h>

int main(void)
{     glp_data *data;
      int j, num, sum;
      /* open plain data file */
      data = glp_sdf_open_file("data.txt");
      if (data == NULL) exit(EXIT_FAILURE);
      sum = 0;
      for (j = 1; j <= 10; j++)
      {  /* read next integer number */
         num = glp_sdf_read_int(data);
         sum += num;
      }
      printf("sum = %d\n", sum);
      /* close plain data file */
      glp_sdf_close_file(data);
      return 0;
}

/* eof */
\end{verbatim}
\end{footnotesize}

The input data are coded in free format. For example, the file
\verb|data.txt| may look like this:

\begin{footnotesize}
\begin{verbatim}
123 65 432 890 -12 743 895 -7 111 326
\end{verbatim}
\end{footnotesize}

\noindent
or like this:

\begin{footnotesize}
\begin{verbatim}
123   65  432  890  -12
743  895   -7  111  326
\end{verbatim}
\end{footnotesize}

\noindent
If the input data file contains incorrect data, the routine
\verb|glp_sdf_read_int| prints an error message and, if no error
handling is provided by the application program, abnormally terminates
program execution. For example, the file \verb|data.txt| could contain
the following data:

\begin{footnotesize}
\begin{verbatim}
123   65  432  890  -12
743  895   =7  111  326
\end{verbatim}
\end{footnotesize}

\noindent
in which case the error message would be the following:

\begin{footnotesize}
\begin{verbatim}
data.txt:2: cannot convert `=7' to integer
\end{verbatim}
\end{footnotesize}

\subsubsection*{Example 2}

As it was said above, by default any attempt to read incorrect data
leads to abnormal termination. However, sometimes it is desirable to
catch such errors. This feature is illustrated by the following main
program, which does the same job as in the previous example.

\begin{footnotesize}
\begin{verbatim}
/* sdfsamp2.c */

#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <glpk.h>

int main(void)
{     glp_data *data;
      jmp_buf jump;
      int j, num, sum, ret;
      /* open plain data file */
      data = glp_sdf_open_file("data.txt");
      if (data == NULL)
      {  ret = EXIT_FAILURE;
         goto done;
      }
      /* set up error handling */
      if (setjmp(jump))
      {  ret = EXIT_FAILURE;
         goto done;
      }
      glp_sdf_set_jump(data, jump);
      /* read and process data */
      sum = 0;
      for (j = 1; j <= 10; j++)
      {  /* read next integer number */
         num = glp_sdf_read_int(data);
         if (abs(num) > 1000)
            glp_sdf_error(data, "integer %d too big\n", num);
         if (num < 0)
            glp_sdf_warning(data, "integer %d is negative\n", num);
         sum += num;
      }
      printf("sum = %d\n", sum);
      ret = EXIT_SUCCESS;
done: /* close plain data file */
      if (data != NULL) glp_sdf_close_file(data);
      return ret;
}

/* eof */
\end{verbatim}
\end{footnotesize}

\subsection{glp\_sdf\_open\_file---open plain data file}

\subsubsection*{Synopsis}

\begin{verbatim}
glp_data *glp_sdf_open_file(const char *fname);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_open_file| opens a plain data file, whose
name is specified by the character string \verb|fname|.

\subsubsection*{Returns}

If the operation was successful, the routine \verb|glp_sdf_open_file|
returns a pointer to the opaque program object of the type
\verb|glp_data|\footnote{This data structure is declared in the header
file {\tt glpk.h}.} associated with the plain data file. Otherwise, if
the operation failed, the routine prints an error message and returns
\verb|NULL|.

\subsubsection*{Note}

The application program should use the pointer returned by the routine
\verb|glp_sdf_open_file| to perform all subsequent operations on the
data file.

\newpage

\subsection{glp\_sdf\_set\_jump---set up error handling}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_sdf_set_jump(glp_data *data, jmp_buf jump);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_set_jump| sets up error handling for the
plain data file specified by the parameter \verb|data|.

The parameter \verb|jump| specifies the environment buffer, which must
be initialized with the standard C function \verb|setjmp| prior to call
to the routine \verb|glp_sdf_set_jump|. Detecting any incorrect data in
the corresponding plain data file will cause non-local ``go to'' by
a call to the standard C function \verb|longjmp|.

The parameter \verb|jump| can be specified as \verb|NULL|, in which
case the routine \verb|glp_sdf_set_jump| restores the default behavior,
in which case detecting incorrect data leads to abnormal termination.

\subsection{glp\_sdf\_error---print error message}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_sdf_error(glp_data *data, const char *fmt, ...);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_error| prints an error message related to the
plain data file specified by the parameter \verb|data|. If error handing
was not previously provided, the routine then abnormally terminates
execution of the application program. Otherwise, it signals about the
error by a call to the standard C function \verb|longjmp|.

The character string \verb|fmt| and optional parameters following it
have the same meaning as for the standard C function \verb|printf|.

The message produced by the routine \verb|glp_sdf_error| looks like
follows:

\medskip

{\it file}{\tt :}{\it line}{\tt :} {\it message text}

\medskip

\noindent
where {\it file} is the filename passed to the routine
\verb|glp_sdf_open| and {\it line} is the current line number.

\newpage

\subsection{glp\_sdf\_warning---print warning message}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_sdf_warning(glp_data *data, const char *fmt, ...);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_warning| prints a warning message related to
the plain data file specified by the parameter \verb|data|.

The character string \verb|fmt| and optional parameters following it
have the same meaning as for the standard C function \verb|printf|.

The message produced by the routine \verb|glp_sdf_warning| looks like
follows:

\medskip

{\it file}{\tt :}{\it line}\verb|: warning:| {\it message text}

\medskip

\noindent
where {\it file} is the filename passed to the routine
\verb|glp_sdf_open| and {\it line} is the current line number.

\subsection{glp\_sdf\_read\_int---read integer number}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_sdf_read_int(glp_data *data);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_read_int| skips optional white-space
characters and then reads an integer number from the plain data file
specified by the parameter \verb|data|. If the operation failed, the
routine \verb|glp_sdf_read_int| calls the routine \verb|glp_sdf_error|
(see above).

\subsubsection*{Returns}

The routine \verb|glp_sdf_read_int| returns the integer number read.

\newpage

\subsection{glp\_sdf\_read\_num---read floating-point number}

\subsubsection*{Synopsis}

\begin{verbatim}
double glp_sdf_read_num(glp_data *data);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_read_num| skips optional white-space
characters and then reads a floating-point number from the plain data
file specified by the parameter \verb|data|. If the operation failed,
the routine \verb|glp_sdf_num| calls the routine \verb|glp_sdf_error|
(see above).

\subsubsection*{Returns}

The routine \verb|glp_sdf_read_num| returns the floating-point number
read.

\subsection{glp\_sdf\_read\_item---read data item}

\subsubsection*{Synopsis}

\begin{verbatim}
const char *glp_sdf_read_item(glp_data *data);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_read_item| skips optional white-space
characters and then reads a data item from the plain data file specified
by the parameter \verb|data|. If the operation failed, the routine
\verb|glp_sdf_read_item| calls the routine \verb|glp_sdf_error| (see
above).

{\it Data item} is a sequence of 1 to 255 arbitrary graphic characters
delimited by white-space characters. Data items may be used to represent
symbolic names, identifiers, etc.

\subsubsection*{Returns}

The routine \verb|glp_sdf_read_item| returns a pointer to the internal
buffer, which contains the data item read in the form of a
null-terminated character string.

\newpage

\subsection{glp\_sdf\_read\_text---read text until end of line}

\subsubsection*{Synopsis}

\begin{verbatim}
const char *glp_sdf_read_text(glp_data *data);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_read_text| reads a text from the plain data
file specified by the parameter \verb|data|.

Reading starts from the current position and extends until end of the
current line. Initial and trailing white-space characters as well as
the newline character are not included in the text.

\subsubsection*{Returns}

The routine \verb|glp_sdf_read_text| returns a pointer to the internal
buffer, which contains the text read in the form of a null-terminated
character string.

\subsection{glp\_sdf\_line---determine current line number}

\subsubsection*{Synopsis}

\begin{verbatim}
int glp_sdf_line(glp_data *data);
\end{verbatim}

\subsubsection*{Returns}

The routine \verb|glp_sdf_line| returns the current line number for the
plain data file specified by the parameter \verb|data|.

\subsection{glp\_sdf\_close\_file---close plain data file}

\subsubsection*{Synopsis}

\begin{verbatim}
void glp_sdf_close_file(glp_data *data);
\end{verbatim}

\subsubsection*{Description}

The routine \verb|glp_sdf_close_file| closes the plain data file
specified by the parameter \verb|data| and frees all the resources
allocated to this program object.

%* eof *%