glpk02.tex

著名的大规模线性规划求解器源码GLPK.C语言版本,可以修剪.内有详细帮助文档.

\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\_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.

\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