| rev |
line source |
|
alpar@9
|
1 %* glpk01.tex *%
|
|
alpar@9
|
2
|
|
alpar@9
|
3 \chapter{Introduction}
|
|
alpar@9
|
4
|
|
alpar@9
|
5 GLPK (\underline{G}NU \underline{L}inear \underline{P}rogramming
|
|
alpar@9
|
6 \underline{K}it) is a set of routines written in the ANSI C programming
|
|
alpar@9
|
7 language and organized in the form of a callable library. It is intended
|
|
alpar@9
|
8 for solving linear programming (LP), mixed integer programming (MIP),
|
|
alpar@9
|
9 and other related problems.
|
|
alpar@9
|
10
|
|
alpar@9
|
11 \section{LP problem}
|
|
alpar@9
|
12 \label{seclp}
|
|
alpar@9
|
13
|
|
alpar@9
|
14 GLPK assumes the following formulation of {\it linear programming (LP)}
|
|
alpar@9
|
15 problem:
|
|
alpar@9
|
16
|
|
alpar@9
|
17 \medskip
|
|
alpar@9
|
18
|
|
alpar@9
|
19 \noindent
|
|
alpar@9
|
20 \hspace{.5in} minimize (or maximize)
|
|
alpar@9
|
21 $$z = c_1x_{m+1} + c_2x_{m+2} + \dots + c_nx_{m+n} + c_0 \eqno (1.1)$$
|
|
alpar@9
|
22 \hspace{.5in} subject to linear constraints
|
|
alpar@9
|
23 $$
|
|
alpar@9
|
24 \begin{array}{r@{\:}c@{\:}r@{\:}c@{\:}r@{\:}c@{\:}r}
|
|
alpar@9
|
25 x_1&=&a_{11}x_{m+1}&+&a_{12}x_{m+2}&+ \dots +&a_{1n}x_{m+n} \\
|
|
alpar@9
|
26 x_2&=&a_{21}x_{m+1}&+&a_{22}x_{m+2}&+ \dots +&a_{2n}x_{m+n} \\
|
|
alpar@9
|
27 \multicolumn{7}{c}
|
|
alpar@9
|
28 {.\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .\ \ .} \\
|
|
alpar@9
|
29 x_m&=&a_{m1}x_{m+1}&+&a_{m2}x_{m+2}&+ \dots +&a_{mn}x_{m+n} \\
|
|
alpar@9
|
30 \end{array} \eqno (1.2)
|
|
alpar@9
|
31 $$
|
|
alpar@9
|
32 \hspace{.5in} and bounds of variables
|
|
alpar@9
|
33 $$
|
|
alpar@9
|
34 \begin{array}{r@{\:}c@{\:}c@{\:}c@{\:}l}
|
|
alpar@9
|
35 l_1&\leq&x_1&\leq&u_1 \\
|
|
alpar@9
|
36 l_2&\leq&x_2&\leq&u_2 \\
|
|
alpar@9
|
37 \multicolumn{5}{c}{.\ \ .\ \ .\ \ .\ \ .}\\
|
|
alpar@9
|
38 l_{m+n}&\leq&x_{m+n}&\leq&u_{m+n} \\
|
|
alpar@9
|
39 \end{array} \eqno (1.3)
|
|
alpar@9
|
40 $$
|
|
alpar@9
|
41 where: $x_1, x_2, \dots, x_m$ are auxiliary variables;
|
|
alpar@9
|
42 $x_{m+1}, x_{m+2}, \dots, x_{m+n}$ are\linebreak structural variables;
|
|
alpar@9
|
43 $z$ is the objective function;
|
|
alpar@9
|
44 $c_1, c_2, \dots, c_n$ are objective coefficients;
|
|
alpar@9
|
45 $c_0$ is the constant term (``shift'') of the objective function;
|
|
alpar@9
|
46 $a_{11}, a_{12}, \dots, a_{mn}$ are constraint coefficients;
|
|
alpar@9
|
47 $l_1, l_2, \dots, l_{m+n}$ are lower bounds of variables;
|
|
alpar@9
|
48 $u_1, u_2, \dots, u_{m+n}$ are upper bounds of variables.
|
|
alpar@9
|
49
|
|
alpar@9
|
50 Auxiliary variables are also called {\it rows}, because they correspond
|
|
alpar@9
|
51 to rows of the constraint matrix (i.e. a matrix built of the constraint
|
|
alpar@9
|
52 coefficients). Similarly, structural variables are also called
|
|
alpar@9
|
53 {\it columns}, because they correspond to columns of the constraint
|
|
alpar@9
|
54 matrix.
|
|
alpar@9
|
55
|
|
alpar@9
|
56 Bounds of variables can be finite as well as infinite. Besides, lower
|
|
alpar@9
|
57 and upper bounds can be equal to each other. Thus, the following types
|
|
alpar@9
|
58 of variables are possible:
|
|
alpar@9
|
59 \begin{center}
|
|
alpar@9
|
60 \begin{tabular}{r@{}c@{}ll}
|
|
alpar@9
|
61 \multicolumn{3}{c}{Bounds of variable} & Type of variable \\
|
|
alpar@9
|
62 \hline
|
|
alpar@9
|
63 $-\infty <$ &$\ x_k\ $& $< +\infty$ & Free (unbounded) variable \\
|
|
alpar@9
|
64 $l_k \leq$ &$\ x_k\ $& $< +\infty$ & Variable with lower bound \\
|
|
alpar@9
|
65 $-\infty <$ &$\ x_k\ $& $\leq u_k$ & Variable with upper bound \\
|
|
alpar@9
|
66 $l_k \leq$ &$\ x_k\ $& $\leq u_k$ & Double-bounded variable \\
|
|
alpar@9
|
67 $l_k =$ &$\ x_k\ $& $= u_k$ & Fixed variable \\
|
|
alpar@9
|
68 \end{tabular}
|
|
alpar@9
|
69 \end{center}
|
|
alpar@9
|
70 \noindent
|
|
alpar@9
|
71 Note that the types of variables shown above are applicable to
|
|
alpar@9
|
72 structural as well as to auxiliary variables.
|
|
alpar@9
|
73
|
|
alpar@9
|
74 To solve the LP problem (1.1)---(1.3) is to find such values of all
|
|
alpar@9
|
75 structural and auxiliary variables, which:
|
|
alpar@9
|
76
|
|
alpar@9
|
77 $\bullet$ satisfy to all the linear constraints (1.2), and
|
|
alpar@9
|
78
|
|
alpar@9
|
79 $\bullet$ are within their bounds (1.3), and
|
|
alpar@9
|
80
|
|
alpar@9
|
81 $\bullet$ provide the smallest (in case of minimization) or the largest
|
|
alpar@9
|
82 (in case of maximization) value of the objective function (1.1).
|
|
alpar@9
|
83
|
|
alpar@9
|
84 \section{MIP problem}
|
|
alpar@9
|
85
|
|
alpar@9
|
86 {\it Mixed integer linear programming (MIP)} problem is LP problem in
|
|
alpar@9
|
87 which some variables are additionally required to be integer.
|
|
alpar@9
|
88
|
|
alpar@9
|
89 GLPK assumes that MIP problem has the same formulation as ordinary
|
|
alpar@9
|
90 (pure) LP problem (1.1)---(1.3), i.e. includes auxiliary and structural
|
|
alpar@9
|
91 variables, which may have lower and/or upper bounds. However, in case of
|
|
alpar@9
|
92 MIP problem some variables may be required to be integer. This
|
|
alpar@9
|
93 additional constraint means that a value of each {\it integer variable}
|
|
alpar@9
|
94 must be only integer number. (Should note that GLPK allows only
|
|
alpar@9
|
95 structural variables to be of integer kind.)
|
|
alpar@9
|
96
|
|
alpar@9
|
97 \section{Using the package}
|
|
alpar@9
|
98
|
|
alpar@9
|
99 \subsection{Brief example}
|
|
alpar@9
|
100
|
|
alpar@9
|
101 In order to understand what GLPK is from the user's standpoint,
|
|
alpar@9
|
102 consider the following simple LP problem:
|
|
alpar@9
|
103
|
|
alpar@9
|
104 \medskip
|
|
alpar@9
|
105
|
|
alpar@9
|
106 \noindent
|
|
alpar@9
|
107 \hspace{.5in} maximize
|
|
alpar@9
|
108 $$z = 10 x_1 + 6 x_2 + 4 x_3$$
|
|
alpar@9
|
109 \hspace{.5in} subject to
|
|
alpar@9
|
110 $$
|
|
alpar@9
|
111 \begin{array}{r@{\:}c@{\:}r@{\:}c@{\:}r@{\:}c@{\:}r}
|
|
alpar@9
|
112 x_1 &+&x_2 &+&x_3 &\leq 100 \\
|
|
alpar@9
|
113 10 x_1 &+& 4 x_2 & +&5 x_3 & \leq 600 \\
|
|
alpar@9
|
114 2 x_1 &+& 2 x_2 & +& 6 x_3 & \leq 300 \\
|
|
alpar@9
|
115 \end{array}
|
|
alpar@9
|
116 $$
|
|
alpar@9
|
117 \hspace{.5in} where all variables are non-negative
|
|
alpar@9
|
118 $$x_1 \geq 0, \ x_2 \geq 0, \ x_3 \geq 0$$
|
|
alpar@9
|
119
|
|
alpar@9
|
120 At first this LP problem should be transformed to the standard form
|
|
alpar@9
|
121 (1.1)---(1.3). This can be easily done by introducing auxiliary
|
|
alpar@9
|
122 variables, by one for each original inequality constraint. Thus, the
|
|
alpar@9
|
123 problem can be reformulated as follows:
|
|
alpar@9
|
124
|
|
alpar@9
|
125 \medskip
|
|
alpar@9
|
126
|
|
alpar@9
|
127 \noindent
|
|
alpar@9
|
128 \hspace{.5in} maximize
|
|
alpar@9
|
129 $$z = 10 x_1 + 6 x_2 + 4 x_3$$
|
|
alpar@9
|
130 \hspace{.5in} subject to
|
|
alpar@9
|
131 $$
|
|
alpar@9
|
132 \begin{array}{r@{\:}c@{\:}r@{\:}c@{\:}r@{\:}c@{\:}r}
|
|
alpar@9
|
133 p& = &x_1 &+&x_2 &+&x_3 \\
|
|
alpar@9
|
134 q& = &10 x_1 &+& 4 x_2 &+& 5 x_3 \\
|
|
alpar@9
|
135 r& = &2 x_1 &+& 2 x_2 &+& 6 x_3 \\
|
|
alpar@9
|
136 \end{array}
|
|
alpar@9
|
137 $$
|
|
alpar@9
|
138 \hspace{.5in} and bounds of variables
|
|
alpar@9
|
139 $$
|
|
alpar@9
|
140 \begin{array}{ccc}
|
|
alpar@9
|
141 \nonumber -\infty < p \leq 100 && 0 \leq x_1 < +\infty \\
|
|
alpar@9
|
142 \nonumber -\infty < q \leq 600 && 0 \leq x_2 < +\infty \\
|
|
alpar@9
|
143 \nonumber -\infty < r \leq 300 && 0 \leq x_3 < +\infty \\
|
|
alpar@9
|
144 \end{array}
|
|
alpar@9
|
145 $$
|
|
alpar@9
|
146 where $p, q, r$ are auxiliary variables (rows), and $x_1, x_2, x_3$ are
|
|
alpar@9
|
147 structural variables (columns).
|
|
alpar@9
|
148
|
|
alpar@9
|
149 The example C program shown below uses GLPK API routines in order to
|
|
alpar@9
|
150 solve this LP problem.\footnote{If you just need to solve LP or MIP
|
|
alpar@9
|
151 instance, you may write it in MPS or CPLEX LP format and then use the
|
|
alpar@9
|
152 GLPK stand-alone solver to obtain a solution. This is much less
|
|
alpar@9
|
153 time-consuming than programming in C with GLPK API routines.}
|
|
alpar@9
|
154
|
|
alpar@9
|
155 \newpage
|
|
alpar@9
|
156
|
|
alpar@9
|
157 \begin{verbatim}
|
|
alpar@9
|
158 /* sample.c */
|
|
alpar@9
|
159
|
|
alpar@9
|
160 #include <stdio.h>
|
|
alpar@9
|
161 #include <stdlib.h>
|
|
alpar@9
|
162 #include <glpk.h>
|
|
alpar@9
|
163
|
|
alpar@9
|
164 int main(void)
|
|
alpar@9
|
165 { glp_prob *lp;
|
|
alpar@9
|
166 int ia[1+1000], ja[1+1000];
|
|
alpar@9
|
167 double ar[1+1000], z, x1, x2, x3;
|
|
alpar@9
|
168 s1: lp = glp_create_prob();
|
|
alpar@9
|
169 s2: glp_set_prob_name(lp, "sample");
|
|
alpar@9
|
170 s3: glp_set_obj_dir(lp, GLP_MAX);
|
|
alpar@9
|
171 s4: glp_add_rows(lp, 3);
|
|
alpar@9
|
172 s5: glp_set_row_name(lp, 1, "p");
|
|
alpar@9
|
173 s6: glp_set_row_bnds(lp, 1, GLP_UP, 0.0, 100.0);
|
|
alpar@9
|
174 s7: glp_set_row_name(lp, 2, "q");
|
|
alpar@9
|
175 s8: glp_set_row_bnds(lp, 2, GLP_UP, 0.0, 600.0);
|
|
alpar@9
|
176 s9: glp_set_row_name(lp, 3, "r");
|
|
alpar@9
|
177 s10: glp_set_row_bnds(lp, 3, GLP_UP, 0.0, 300.0);
|
|
alpar@9
|
178 s11: glp_add_cols(lp, 3);
|
|
alpar@9
|
179 s12: glp_set_col_name(lp, 1, "x1");
|
|
alpar@9
|
180 s13: glp_set_col_bnds(lp, 1, GLP_LO, 0.0, 0.0);
|
|
alpar@9
|
181 s14: glp_set_obj_coef(lp, 1, 10.0);
|
|
alpar@9
|
182 s15: glp_set_col_name(lp, 2, "x2");
|
|
alpar@9
|
183 s16: glp_set_col_bnds(lp, 2, GLP_LO, 0.0, 0.0);
|
|
alpar@9
|
184 s17: glp_set_obj_coef(lp, 2, 6.0);
|
|
alpar@9
|
185 s18: glp_set_col_name(lp, 3, "x3");
|
|
alpar@9
|
186 s19: glp_set_col_bnds(lp, 3, GLP_LO, 0.0, 0.0);
|
|
alpar@9
|
187 s20: glp_set_obj_coef(lp, 3, 4.0);
|
|
alpar@9
|
188 s21: ia[1] = 1, ja[1] = 1, ar[1] = 1.0; /* a[1,1] = 1 */
|
|
alpar@9
|
189 s22: ia[2] = 1, ja[2] = 2, ar[2] = 1.0; /* a[1,2] = 1 */
|
|
alpar@9
|
190 s23: ia[3] = 1, ja[3] = 3, ar[3] = 1.0; /* a[1,3] = 1 */
|
|
alpar@9
|
191 s24: ia[4] = 2, ja[4] = 1, ar[4] = 10.0; /* a[2,1] = 10 */
|
|
alpar@9
|
192 s25: ia[5] = 3, ja[5] = 1, ar[5] = 2.0; /* a[3,1] = 2 */
|
|
alpar@9
|
193 s26: ia[6] = 2, ja[6] = 2, ar[6] = 4.0; /* a[2,2] = 4 */
|
|
alpar@9
|
194 s27: ia[7] = 3, ja[7] = 2, ar[7] = 2.0; /* a[3,2] = 2 */
|
|
alpar@9
|
195 s28: ia[8] = 2, ja[8] = 3, ar[8] = 5.0; /* a[2,3] = 5 */
|
|
alpar@9
|
196 s29: ia[9] = 3, ja[9] = 3, ar[9] = 6.0; /* a[3,3] = 6 */
|
|
alpar@9
|
197 s30: glp_load_matrix(lp, 9, ia, ja, ar);
|
|
alpar@9
|
198 s31: glp_simplex(lp, NULL);
|
|
alpar@9
|
199 s32: z = glp_get_obj_val(lp);
|
|
alpar@9
|
200 s33: x1 = glp_get_col_prim(lp, 1);
|
|
alpar@9
|
201 s34: x2 = glp_get_col_prim(lp, 2);
|
|
alpar@9
|
202 s35: x3 = glp_get_col_prim(lp, 3);
|
|
alpar@9
|
203 s36: printf("\nz = %g; x1 = %g; x2 = %g; x3 = %g\n",
|
|
alpar@9
|
204 z, x1, x2, x3);
|
|
alpar@9
|
205 s37: glp_delete_prob(lp);
|
|
alpar@9
|
206 return 0;
|
|
alpar@9
|
207 }
|
|
alpar@9
|
208
|
|
alpar@9
|
209 /* eof */
|
|
alpar@9
|
210 \end{verbatim}
|
|
alpar@9
|
211
|
|
alpar@9
|
212 The statement \verb|s1| creates a problem object. Being created the
|
|
alpar@9
|
213 object is initially empty. The statement \verb|s2| assigns a symbolic
|
|
alpar@9
|
214 name to the problem object.
|
|
alpar@9
|
215
|
|
alpar@9
|
216 The statement \verb|s3| calls the routine \verb|glp_set_obj_dir| in
|
|
alpar@9
|
217 order to set the optimization direction flag, where \verb|GLP_MAX| means
|
|
alpar@9
|
218 maximization.
|
|
alpar@9
|
219
|
|
alpar@9
|
220 The statement \verb|s4| adds three rows to the problem object.
|
|
alpar@9
|
221
|
|
alpar@9
|
222 The statement \verb|s5| assigns the symbolic name `\verb|p|' to the
|
|
alpar@9
|
223 first row, and the statement \verb|s6| sets the type and bounds of the
|
|
alpar@9
|
224 first row, where \verb|GLP_UP| means that the row has an upper bound.
|
|
alpar@9
|
225 The statements \verb|s7|, \verb|s8|, \verb|s9|, \verb|s10| are used in
|
|
alpar@9
|
226 the same way in order to assign the symbolic names `\verb|q|' and
|
|
alpar@9
|
227 `\verb|r|' to the second and third rows and set their types and bounds.
|
|
alpar@9
|
228
|
|
alpar@9
|
229 The statement \verb|s11| adds three columns to the problem object.
|
|
alpar@9
|
230
|
|
alpar@9
|
231 The statement \verb|s12| assigns the symbolic name `\verb|x1|' to the
|
|
alpar@9
|
232 first column, the statement \verb|s13| sets the type and bounds of the
|
|
alpar@9
|
233 first column, where \verb|GLP_LO| means that the column has an lower
|
|
alpar@9
|
234 bound, and the statement \verb|s14| sets the objective coefficient for
|
|
alpar@9
|
235 the first column. The statements \verb|s15|---\verb|s20| are used in the
|
|
alpar@9
|
236 same way in order to assign the symbolic names `\verb|x2|' and
|
|
alpar@9
|
237 `\verb|x3|' to the second and third columns and set their types, bounds,
|
|
alpar@9
|
238 and objective coefficients.
|
|
alpar@9
|
239
|
|
alpar@9
|
240 The statements \verb|s21|---\verb|s29| prepare non-zero elements of the
|
|
alpar@9
|
241 constraint matrix (i.e. constraint coefficients). Row indices of each
|
|
alpar@9
|
242 element are stored in the array \verb|ia|, column indices are stored in
|
|
alpar@9
|
243 the array \verb|ja|, and numerical values of corresponding elements are
|
|
alpar@9
|
244 stored in the array \verb|ar|. Then the statement \verb|s30| calls
|
|
alpar@9
|
245 the routine \verb|glp_load_matrix|, which loads information from these
|
|
alpar@9
|
246 three arrays into the problem object.
|
|
alpar@9
|
247
|
|
alpar@9
|
248 Now all data have been entered into the problem object, and therefore
|
|
alpar@9
|
249 the statement \verb|s31| calls the routine \verb|glp_simplex|, which is
|
|
alpar@9
|
250 a driver to the simplex method, in order to solve the LP problem. This
|
|
alpar@9
|
251 routine finds an optimal solution and stores all relevant information
|
|
alpar@9
|
252 back into the problem object.
|
|
alpar@9
|
253
|
|
alpar@9
|
254 The statement \verb|s32| obtains a computed value of the objective
|
|
alpar@9
|
255 function, and the statements \verb|s33|---\verb|s35| obtain computed
|
|
alpar@9
|
256 values of structural variables (columns), which correspond to the
|
|
alpar@9
|
257 optimal basic solution found by the solver.
|
|
alpar@9
|
258
|
|
alpar@9
|
259 The statement \verb|s36| writes the optimal solution to the standard
|
|
alpar@9
|
260 output. The printout may look like follows:
|
|
alpar@9
|
261
|
|
alpar@9
|
262 {\footnotesize
|
|
alpar@9
|
263 \begin{verbatim}
|
|
alpar@9
|
264 * 0: objval = 0.000000000e+00 infeas = 0.000000000e+00 (0)
|
|
alpar@9
|
265 * 2: objval = 7.333333333e+02 infeas = 0.000000000e+00 (0)
|
|
alpar@9
|
266 OPTIMAL SOLUTION FOUND
|
|
alpar@9
|
267
|
|
alpar@9
|
268 z = 733.333; x1 = 33.3333; x2 = 66.6667; x3 = 0
|
|
alpar@9
|
269 \end{verbatim}
|
|
alpar@9
|
270
|
|
alpar@9
|
271 }
|
|
alpar@9
|
272
|
|
alpar@9
|
273 Finally, the statement \verb|s37| calls the routine
|
|
alpar@9
|
274 \verb|glp_delete_prob|, which frees all the memory allocated to the
|
|
alpar@9
|
275 problem object.
|
|
alpar@9
|
276
|
|
alpar@9
|
277 \subsection{Compiling}
|
|
alpar@9
|
278
|
|
alpar@9
|
279 The GLPK package has the only header file \verb|glpk.h|, which should
|
|
alpar@9
|
280 be available on compiling a C (or C++) program using GLPK API routines.
|
|
alpar@9
|
281
|
|
alpar@9
|
282 If the header file is installed in the default location
|
|
alpar@9
|
283 \verb|/usr/local/include|, the following typical command may be used to
|
|
alpar@9
|
284 compile, say, the example C program described above with the GNU C
|
|
alpar@9
|
285 compiler:
|
|
alpar@9
|
286
|
|
alpar@9
|
287 \begin{verbatim}
|
|
alpar@9
|
288 $ gcc -c sample.c
|
|
alpar@9
|
289 \end{verbatim}
|
|
alpar@9
|
290
|
|
alpar@9
|
291 If \verb|glpk.h| is not in the default location, the corresponding
|
|
alpar@9
|
292 directory containing it should be made known to the C compiler through
|
|
alpar@9
|
293 \verb|-I| option, for example:
|
|
alpar@9
|
294
|
|
alpar@9
|
295 \begin{verbatim}
|
|
alpar@9
|
296 $ gcc -I/foo/bar/glpk-4.15/include -c sample.c
|
|
alpar@9
|
297 \end{verbatim}
|
|
alpar@9
|
298
|
|
alpar@9
|
299 In any case the compilation results in an object file \verb|sample.o|.
|
|
alpar@9
|
300
|
|
alpar@9
|
301 \subsection{Linking}
|
|
alpar@9
|
302
|
|
alpar@9
|
303 The GLPK library is a single file \verb|libglpk.a|. (On systems which
|
|
alpar@9
|
304 support shared libraries there may be also a shared version of the
|
|
alpar@9
|
305 library \verb|libglpk.so|.)
|
|
alpar@9
|
306
|
|
alpar@9
|
307 If the library is installed in the default
|
|
alpar@9
|
308 location \verb|/usr/local/lib|, the following typical command may be
|
|
alpar@9
|
309 used to link, say, the example C program described above against with
|
|
alpar@9
|
310 the library:
|
|
alpar@9
|
311
|
|
alpar@9
|
312 \begin{verbatim}
|
|
alpar@9
|
313 $ gcc sample.o -lglpk -lm
|
|
alpar@9
|
314 \end{verbatim}
|
|
alpar@9
|
315
|
|
alpar@9
|
316 If the GLPK library is not in the default location, the corresponding
|
|
alpar@9
|
317 directory containing it should be made known to the linker through
|
|
alpar@9
|
318 \verb|-L| option, for example:
|
|
alpar@9
|
319
|
|
alpar@9
|
320 \begin{verbatim}
|
|
alpar@9
|
321 $ gcc -L/foo/bar/glpk-4.15 sample.o -lglpk -lm
|
|
alpar@9
|
322 \end{verbatim}
|
|
alpar@9
|
323
|
|
alpar@9
|
324 Depending on configuration of the package linking against with the GLPK
|
|
alpar@9
|
325 library may require the following optional libraries:
|
|
alpar@9
|
326
|
|
alpar@9
|
327 \bigskip
|
|
alpar@9
|
328
|
|
alpar@9
|
329 \begin{tabular}{@{}ll}
|
|
alpar@9
|
330 \verb|-lgmp| & the GNU MP bignum library; \\
|
|
alpar@9
|
331 \verb|-lz| & the zlib data compression library; \\
|
|
alpar@9
|
332 \verb|-lltdl| & the GNU ltdl shared support library. \\
|
|
alpar@9
|
333 \end{tabular}
|
|
alpar@9
|
334
|
|
alpar@9
|
335 \bigskip
|
|
alpar@9
|
336
|
|
alpar@9
|
337 \noindent
|
|
alpar@9
|
338 in which case corresponding libraries should be also made known to the
|
|
alpar@9
|
339 linker, for example:
|
|
alpar@9
|
340
|
|
alpar@9
|
341 \begin{verbatim}
|
|
alpar@9
|
342 $ gcc sample.o -lglpk -lz -lltdl -lm
|
|
alpar@9
|
343 \end{verbatim}
|
|
alpar@9
|
344
|
|
alpar@9
|
345 For more details about configuration options of the GLPK package see
|
|
alpar@9
|
346 Appendix \ref{install}, page \pageref{install}.
|
|
alpar@9
|
347
|
|
alpar@9
|
348 %* eof *%
|
