3 /***********************************************************************
4 * This code is part of GLPK (GNU Linear Programming Kit).
6 * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7 * 2009, 2010 Andrew Makhorin, Department for Applied Informatics,
8 * Moscow Aviation Institute, Moscow, Russia. All rights reserved.
9 * E-mail: <mao@gnu.org>.
11 * GLPK is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation, either version 3 of the License, or
14 * (at your option) any later version.
16 * GLPK is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 * License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with GLPK. If not, see <http://www.gnu.org/licenses/>.
23 ***********************************************************************/
35 /* library version numbers: */
36 #define GLP_MAJOR_VERSION 4
37 #define GLP_MINOR_VERSION 45
39 #ifndef GLP_PROB_DEFINED
40 #define GLP_PROB_DEFINED
41 typedef struct { double _opaque_prob[100]; } glp_prob;
42 /* LP/MIP problem object */
45 /* optimization direction flag: */
46 #define GLP_MIN 1 /* minimization */
47 #define GLP_MAX 2 /* maximization */
49 /* kind of structural variable: */
50 #define GLP_CV 1 /* continuous variable */
51 #define GLP_IV 2 /* integer variable */
52 #define GLP_BV 3 /* binary variable */
54 /* type of auxiliary/structural variable: */
55 #define GLP_FR 1 /* free variable */
56 #define GLP_LO 2 /* variable with lower bound */
57 #define GLP_UP 3 /* variable with upper bound */
58 #define GLP_DB 4 /* double-bounded variable */
59 #define GLP_FX 5 /* fixed variable */
61 /* status of auxiliary/structural variable: */
62 #define GLP_BS 1 /* basic variable */
63 #define GLP_NL 2 /* non-basic variable on lower bound */
64 #define GLP_NU 3 /* non-basic variable on upper bound */
65 #define GLP_NF 4 /* non-basic free variable */
66 #define GLP_NS 5 /* non-basic fixed variable */
68 /* scaling options: */
69 #define GLP_SF_GM 0x01 /* perform geometric mean scaling */
70 #define GLP_SF_EQ 0x10 /* perform equilibration scaling */
71 #define GLP_SF_2N 0x20 /* round scale factors to power of two */
72 #define GLP_SF_SKIP 0x40 /* skip if problem is well scaled */
73 #define GLP_SF_AUTO 0x80 /* choose scaling options automatically */
75 /* solution indicator: */
76 #define GLP_SOL 1 /* basic solution */
77 #define GLP_IPT 2 /* interior-point solution */
78 #define GLP_MIP 3 /* mixed integer solution */
80 /* solution status: */
81 #define GLP_UNDEF 1 /* solution is undefined */
82 #define GLP_FEAS 2 /* solution is feasible */
83 #define GLP_INFEAS 3 /* solution is infeasible */
84 #define GLP_NOFEAS 4 /* no feasible solution exists */
85 #define GLP_OPT 5 /* solution is optimal */
86 #define GLP_UNBND 6 /* solution is unbounded */
89 { /* basis factorization control parameters */
90 int msg_lev; /* (reserved) */
91 int type; /* factorization type: */
92 #define GLP_BF_FT 1 /* LUF + Forrest-Tomlin */
93 #define GLP_BF_BG 2 /* LUF + Schur compl. + Bartels-Golub */
94 #define GLP_BF_GR 3 /* LUF + Schur compl. + Givens rotation */
95 int lu_size; /* luf.sv_size */
96 double piv_tol; /* luf.piv_tol */
97 int piv_lim; /* luf.piv_lim */
98 int suhl; /* luf.suhl */
99 double eps_tol; /* luf.eps_tol */
100 double max_gro; /* luf.max_gro */
101 int nfs_max; /* fhv.hh_max */
102 double upd_tol; /* fhv.upd_tol */
103 int nrs_max; /* lpf.n_max */
104 int rs_size; /* lpf.v_size */
105 double foo_bar[38]; /* (reserved) */
109 { /* simplex method control parameters */
110 int msg_lev; /* message level: */
111 #define GLP_MSG_OFF 0 /* no output */
112 #define GLP_MSG_ERR 1 /* warning and error messages only */
113 #define GLP_MSG_ON 2 /* normal output */
114 #define GLP_MSG_ALL 3 /* full output */
115 #define GLP_MSG_DBG 4 /* debug output */
116 int meth; /* simplex method option: */
117 #define GLP_PRIMAL 1 /* use primal simplex */
118 #define GLP_DUALP 2 /* use dual; if it fails, use primal */
119 #define GLP_DUAL 3 /* use dual simplex */
120 int pricing; /* pricing technique: */
121 #define GLP_PT_STD 0x11 /* standard (Dantzig rule) */
122 #define GLP_PT_PSE 0x22 /* projected steepest edge */
123 int r_test; /* ratio test technique: */
124 #define GLP_RT_STD 0x11 /* standard (textbook) */
125 #define GLP_RT_HAR 0x22 /* two-pass Harris' ratio test */
126 double tol_bnd; /* spx.tol_bnd */
127 double tol_dj; /* spx.tol_dj */
128 double tol_piv; /* spx.tol_piv */
129 double obj_ll; /* spx.obj_ll */
130 double obj_ul; /* spx.obj_ul */
131 int it_lim; /* spx.it_lim */
132 int tm_lim; /* spx.tm_lim (milliseconds) */
133 int out_frq; /* spx.out_frq */
134 int out_dly; /* spx.out_dly (milliseconds) */
135 int presolve; /* enable/disable using LP presolver */
136 double foo_bar[36]; /* (reserved) */
140 { /* interior-point solver control parameters */
141 int msg_lev; /* message level (see glp_smcp) */
142 int ord_alg; /* ordering algorithm: */
143 #define GLP_ORD_NONE 0 /* natural (original) ordering */
144 #define GLP_ORD_QMD 1 /* quotient minimum degree (QMD) */
145 #define GLP_ORD_AMD 2 /* approx. minimum degree (AMD) */
146 #define GLP_ORD_SYMAMD 3 /* approx. minimum degree (SYMAMD) */
147 double foo_bar[48]; /* (reserved) */
150 #ifndef GLP_TREE_DEFINED
151 #define GLP_TREE_DEFINED
152 typedef struct { double _opaque_tree[100]; } glp_tree;
153 /* branch-and-bound tree */
157 { /* integer optimizer control parameters */
158 int msg_lev; /* message level (see glp_smcp) */
159 int br_tech; /* branching technique: */
160 #define GLP_BR_FFV 1 /* first fractional variable */
161 #define GLP_BR_LFV 2 /* last fractional variable */
162 #define GLP_BR_MFV 3 /* most fractional variable */
163 #define GLP_BR_DTH 4 /* heuristic by Driebeck and Tomlin */
164 #define GLP_BR_PCH 5 /* hybrid pseudocost heuristic */
165 int bt_tech; /* backtracking technique: */
166 #define GLP_BT_DFS 1 /* depth first search */
167 #define GLP_BT_BFS 2 /* breadth first search */
168 #define GLP_BT_BLB 3 /* best local bound */
169 #define GLP_BT_BPH 4 /* best projection heuristic */
170 double tol_int; /* mip.tol_int */
171 double tol_obj; /* mip.tol_obj */
172 int tm_lim; /* mip.tm_lim (milliseconds) */
173 int out_frq; /* mip.out_frq (milliseconds) */
174 int out_dly; /* mip.out_dly (milliseconds) */
175 void (*cb_func)(glp_tree *T, void *info);
177 void *cb_info; /* mip.cb_info */
178 int cb_size; /* mip.cb_size */
179 int pp_tech; /* preprocessing technique: */
180 #define GLP_PP_NONE 0 /* disable preprocessing */
181 #define GLP_PP_ROOT 1 /* preprocessing only on root level */
182 #define GLP_PP_ALL 2 /* preprocessing on all levels */
183 double mip_gap; /* relative MIP gap tolerance */
184 int mir_cuts; /* MIR cuts (GLP_ON/GLP_OFF) */
185 int gmi_cuts; /* Gomory's cuts (GLP_ON/GLP_OFF) */
186 int cov_cuts; /* cover cuts (GLP_ON/GLP_OFF) */
187 int clq_cuts; /* clique cuts (GLP_ON/GLP_OFF) */
188 int presolve; /* enable/disable using MIP presolver */
189 int binarize; /* try to binarize integer variables */
190 int fp_heur; /* feasibility pump heuristic */
191 #if 1 /* 28/V-2010 */
192 int alien; /* use alien solver */
194 double foo_bar[29]; /* (reserved) */
198 { /* additional row attributes */
200 /* subproblem level at which the row was added */
202 /* row origin flag: */
203 #define GLP_RF_REG 0 /* regular constraint */
204 #define GLP_RF_LAZY 1 /* "lazy" constraint */
205 #define GLP_RF_CUT 2 /* cutting plane constraint */
207 /* row class descriptor: */
208 #define GLP_RF_GMI 1 /* Gomory's mixed integer cut */
209 #define GLP_RF_MIR 2 /* mixed integer rounding cut */
210 #define GLP_RF_COV 3 /* mixed cover cut */
211 #define GLP_RF_CLQ 4 /* clique cut */
216 /* enable/disable flag: */
217 #define GLP_ON 1 /* enable something */
218 #define GLP_OFF 0 /* disable something */
221 #define GLP_IROWGEN 0x01 /* request for row generation */
222 #define GLP_IBINGO 0x02 /* better integer solution found */
223 #define GLP_IHEUR 0x03 /* request for heuristic solution */
224 #define GLP_ICUTGEN 0x04 /* request for cut generation */
225 #define GLP_IBRANCH 0x05 /* request for branching */
226 #define GLP_ISELECT 0x06 /* request for subproblem selection */
227 #define GLP_IPREPRO 0x07 /* request for preprocessing */
229 /* branch selection indicator: */
230 #define GLP_NO_BRNCH 0 /* select no branch */
231 #define GLP_DN_BRNCH 1 /* select down-branch */
232 #define GLP_UP_BRNCH 2 /* select up-branch */
235 #define GLP_EBADB 0x01 /* invalid basis */
236 #define GLP_ESING 0x02 /* singular matrix */
237 #define GLP_ECOND 0x03 /* ill-conditioned matrix */
238 #define GLP_EBOUND 0x04 /* invalid bounds */
239 #define GLP_EFAIL 0x05 /* solver failed */
240 #define GLP_EOBJLL 0x06 /* objective lower limit reached */
241 #define GLP_EOBJUL 0x07 /* objective upper limit reached */
242 #define GLP_EITLIM 0x08 /* iteration limit exceeded */
243 #define GLP_ETMLIM 0x09 /* time limit exceeded */
244 #define GLP_ENOPFS 0x0A /* no primal feasible solution */
245 #define GLP_ENODFS 0x0B /* no dual feasible solution */
246 #define GLP_EROOT 0x0C /* root LP optimum not provided */
247 #define GLP_ESTOP 0x0D /* search terminated by application */
248 #define GLP_EMIPGAP 0x0E /* relative mip gap tolerance reached */
249 #define GLP_ENOFEAS 0x0F /* no primal/dual feasible solution */
250 #define GLP_ENOCVG 0x10 /* no convergence */
251 #define GLP_EINSTAB 0x11 /* numerical instability */
252 #define GLP_EDATA 0x12 /* invalid data */
253 #define GLP_ERANGE 0x13 /* result out of range */
255 /* condition indicator: */
256 #define GLP_KKT_PE 1 /* primal equalities */
257 #define GLP_KKT_PB 2 /* primal bounds */
258 #define GLP_KKT_DE 3 /* dual equalities */
259 #define GLP_KKT_DB 4 /* dual bounds */
260 #define GLP_KKT_CS 5 /* complementary slackness */
262 /* MPS file format: */
263 #define GLP_MPS_DECK 1 /* fixed (ancient) */
264 #define GLP_MPS_FILE 2 /* free (modern) */
267 { /* MPS format control parameters */
269 /* character code to replace blanks in symbolic names */
271 /* objective row name */
273 /* zero tolerance for MPS data */
275 /* (reserved for use in the future) */
279 { /* CPLEX LP format control parameters */
281 /* (reserved for use in the future) */
284 #ifndef GLP_TRAN_DEFINED
285 #define GLP_TRAN_DEFINED
286 typedef struct { double _opaque_tran[100]; } glp_tran;
287 /* MathProg translator workspace */
290 glp_prob *glp_create_prob(void);
291 /* create problem object */
293 void glp_set_prob_name(glp_prob *P, const char *name);
294 /* assign (change) problem name */
296 void glp_set_obj_name(glp_prob *P, const char *name);
297 /* assign (change) objective function name */
299 void glp_set_obj_dir(glp_prob *P, int dir);
300 /* set (change) optimization direction flag */
302 int glp_add_rows(glp_prob *P, int nrs);
303 /* add new rows to problem object */
305 int glp_add_cols(glp_prob *P, int ncs);
306 /* add new columns to problem object */
308 void glp_set_row_name(glp_prob *P, int i, const char *name);
309 /* assign (change) row name */
311 void glp_set_col_name(glp_prob *P, int j, const char *name);
312 /* assign (change) column name */
314 void glp_set_row_bnds(glp_prob *P, int i, int type, double lb,
316 /* set (change) row bounds */
318 void glp_set_col_bnds(glp_prob *P, int j, int type, double lb,
320 /* set (change) column bounds */
322 void glp_set_obj_coef(glp_prob *P, int j, double coef);
323 /* set (change) obj. coefficient or constant term */
325 void glp_set_mat_row(glp_prob *P, int i, int len, const int ind[],
327 /* set (replace) row of the constraint matrix */
329 void glp_set_mat_col(glp_prob *P, int j, int len, const int ind[],
331 /* set (replace) column of the constraint matrix */
333 void glp_load_matrix(glp_prob *P, int ne, const int ia[],
334 const int ja[], const double ar[]);
335 /* load (replace) the whole constraint matrix */
337 int glp_check_dup(int m, int n, int ne, const int ia[], const int ja[]);
338 /* check for duplicate elements in sparse matrix */
340 void glp_sort_matrix(glp_prob *P);
341 /* sort elements of the constraint matrix */
343 void glp_del_rows(glp_prob *P, int nrs, const int num[]);
344 /* delete specified rows from problem object */
346 void glp_del_cols(glp_prob *P, int ncs, const int num[]);
347 /* delete specified columns from problem object */
349 void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names);
350 /* copy problem object content */
352 void glp_erase_prob(glp_prob *P);
353 /* erase problem object content */
355 void glp_delete_prob(glp_prob *P);
356 /* delete problem object */
358 const char *glp_get_prob_name(glp_prob *P);
359 /* retrieve problem name */
361 const char *glp_get_obj_name(glp_prob *P);
362 /* retrieve objective function name */
364 int glp_get_obj_dir(glp_prob *P);
365 /* retrieve optimization direction flag */
367 int glp_get_num_rows(glp_prob *P);
368 /* retrieve number of rows */
370 int glp_get_num_cols(glp_prob *P);
371 /* retrieve number of columns */
373 const char *glp_get_row_name(glp_prob *P, int i);
374 /* retrieve row name */
376 const char *glp_get_col_name(glp_prob *P, int j);
377 /* retrieve column name */
379 int glp_get_row_type(glp_prob *P, int i);
380 /* retrieve row type */
382 double glp_get_row_lb(glp_prob *P, int i);
383 /* retrieve row lower bound */
385 double glp_get_row_ub(glp_prob *P, int i);
386 /* retrieve row upper bound */
388 int glp_get_col_type(glp_prob *P, int j);
389 /* retrieve column type */
391 double glp_get_col_lb(glp_prob *P, int j);
392 /* retrieve column lower bound */
394 double glp_get_col_ub(glp_prob *P, int j);
395 /* retrieve column upper bound */
397 double glp_get_obj_coef(glp_prob *P, int j);
398 /* retrieve obj. coefficient or constant term */
400 int glp_get_num_nz(glp_prob *P);
401 /* retrieve number of constraint coefficients */
403 int glp_get_mat_row(glp_prob *P, int i, int ind[], double val[]);
404 /* retrieve row of the constraint matrix */
406 int glp_get_mat_col(glp_prob *P, int j, int ind[], double val[]);
407 /* retrieve column of the constraint matrix */
409 void glp_create_index(glp_prob *P);
410 /* create the name index */
412 int glp_find_row(glp_prob *P, const char *name);
413 /* find row by its name */
415 int glp_find_col(glp_prob *P, const char *name);
416 /* find column by its name */
418 void glp_delete_index(glp_prob *P);
419 /* delete the name index */
421 void glp_set_rii(glp_prob *P, int i, double rii);
422 /* set (change) row scale factor */
424 void glp_set_sjj(glp_prob *P, int j, double sjj);
425 /* set (change) column scale factor */
427 double glp_get_rii(glp_prob *P, int i);
428 /* retrieve row scale factor */
430 double glp_get_sjj(glp_prob *P, int j);
431 /* retrieve column scale factor */
433 void glp_scale_prob(glp_prob *P, int flags);
434 /* scale problem data */
436 void glp_unscale_prob(glp_prob *P);
437 /* unscale problem data */
439 void glp_set_row_stat(glp_prob *P, int i, int stat);
440 /* set (change) row status */
442 void glp_set_col_stat(glp_prob *P, int j, int stat);
443 /* set (change) column status */
445 void glp_std_basis(glp_prob *P);
446 /* construct standard initial LP basis */
448 void glp_adv_basis(glp_prob *P, int flags);
449 /* construct advanced initial LP basis */
451 void glp_cpx_basis(glp_prob *P);
452 /* construct Bixby's initial LP basis */
454 int glp_simplex(glp_prob *P, const glp_smcp *parm);
455 /* solve LP problem with the simplex method */
457 int glp_exact(glp_prob *P, const glp_smcp *parm);
458 /* solve LP problem in exact arithmetic */
460 void glp_init_smcp(glp_smcp *parm);
461 /* initialize simplex method control parameters */
463 int glp_get_status(glp_prob *P);
464 /* retrieve generic status of basic solution */
466 int glp_get_prim_stat(glp_prob *P);
467 /* retrieve status of primal basic solution */
469 int glp_get_dual_stat(glp_prob *P);
470 /* retrieve status of dual basic solution */
472 double glp_get_obj_val(glp_prob *P);
473 /* retrieve objective value (basic solution) */
475 int glp_get_row_stat(glp_prob *P, int i);
476 /* retrieve row status */
478 double glp_get_row_prim(glp_prob *P, int i);
479 /* retrieve row primal value (basic solution) */
481 double glp_get_row_dual(glp_prob *P, int i);
482 /* retrieve row dual value (basic solution) */
484 int glp_get_col_stat(glp_prob *P, int j);
485 /* retrieve column status */
487 double glp_get_col_prim(glp_prob *P, int j);
488 /* retrieve column primal value (basic solution) */
490 double glp_get_col_dual(glp_prob *P, int j);
491 /* retrieve column dual value (basic solution) */
493 int glp_get_unbnd_ray(glp_prob *P);
494 /* determine variable causing unboundedness */
496 int glp_interior(glp_prob *P, const glp_iptcp *parm);
497 /* solve LP problem with the interior-point method */
499 void glp_init_iptcp(glp_iptcp *parm);
500 /* initialize interior-point solver control parameters */
502 int glp_ipt_status(glp_prob *P);
503 /* retrieve status of interior-point solution */
505 double glp_ipt_obj_val(glp_prob *P);
506 /* retrieve objective value (interior point) */
508 double glp_ipt_row_prim(glp_prob *P, int i);
509 /* retrieve row primal value (interior point) */
511 double glp_ipt_row_dual(glp_prob *P, int i);
512 /* retrieve row dual value (interior point) */
514 double glp_ipt_col_prim(glp_prob *P, int j);
515 /* retrieve column primal value (interior point) */
517 double glp_ipt_col_dual(glp_prob *P, int j);
518 /* retrieve column dual value (interior point) */
520 void glp_set_col_kind(glp_prob *P, int j, int kind);
521 /* set (change) column kind */
523 int glp_get_col_kind(glp_prob *P, int j);
524 /* retrieve column kind */
526 int glp_get_num_int(glp_prob *P);
527 /* retrieve number of integer columns */
529 int glp_get_num_bin(glp_prob *P);
530 /* retrieve number of binary columns */
532 int glp_intopt(glp_prob *P, const glp_iocp *parm);
533 /* solve MIP problem with the branch-and-bound method */
535 void glp_init_iocp(glp_iocp *parm);
536 /* initialize integer optimizer control parameters */
538 int glp_mip_status(glp_prob *P);
539 /* retrieve status of MIP solution */
541 double glp_mip_obj_val(glp_prob *P);
542 /* retrieve objective value (MIP solution) */
544 double glp_mip_row_val(glp_prob *P, int i);
545 /* retrieve row value (MIP solution) */
547 double glp_mip_col_val(glp_prob *P, int j);
548 /* retrieve column value (MIP solution) */
550 int glp_print_sol(glp_prob *P, const char *fname);
551 /* write basic solution in printable format */
553 int glp_read_sol(glp_prob *P, const char *fname);
554 /* read basic solution from text file */
556 int glp_write_sol(glp_prob *P, const char *fname);
557 /* write basic solution to text file */
559 int glp_print_ranges(glp_prob *P, int len, const int list[],
560 int flags, const char *fname);
561 /* print sensitivity analysis report */
563 int glp_print_ipt(glp_prob *P, const char *fname);
564 /* write interior-point solution in printable format */
566 int glp_read_ipt(glp_prob *P, const char *fname);
567 /* read interior-point solution from text file */
569 int glp_write_ipt(glp_prob *P, const char *fname);
570 /* write interior-point solution to text file */
572 int glp_print_mip(glp_prob *P, const char *fname);
573 /* write MIP solution in printable format */
575 int glp_read_mip(glp_prob *P, const char *fname);
576 /* read MIP solution from text file */
578 int glp_write_mip(glp_prob *P, const char *fname);
579 /* write MIP solution to text file */
581 int glp_bf_exists(glp_prob *P);
582 /* check if the basis factorization exists */
584 int glp_factorize(glp_prob *P);
585 /* compute the basis factorization */
587 int glp_bf_updated(glp_prob *P);
588 /* check if the basis factorization has been updated */
590 void glp_get_bfcp(glp_prob *P, glp_bfcp *parm);
591 /* retrieve basis factorization control parameters */
593 void glp_set_bfcp(glp_prob *P, const glp_bfcp *parm);
594 /* change basis factorization control parameters */
596 int glp_get_bhead(glp_prob *P, int k);
597 /* retrieve the basis header information */
599 int glp_get_row_bind(glp_prob *P, int i);
600 /* retrieve row index in the basis header */
602 int glp_get_col_bind(glp_prob *P, int j);
603 /* retrieve column index in the basis header */
605 void glp_ftran(glp_prob *P, double x[]);
606 /* perform forward transformation (solve system B*x = b) */
608 void glp_btran(glp_prob *P, double x[]);
609 /* perform backward transformation (solve system B'*x = b) */
611 int glp_warm_up(glp_prob *P);
612 /* "warm up" LP basis */
614 int glp_eval_tab_row(glp_prob *P, int k, int ind[], double val[]);
615 /* compute row of the simplex tableau */
617 int glp_eval_tab_col(glp_prob *P, int k, int ind[], double val[]);
618 /* compute column of the simplex tableau */
620 int glp_transform_row(glp_prob *P, int len, int ind[], double val[]);
621 /* transform explicitly specified row */
623 int glp_transform_col(glp_prob *P, int len, int ind[], double val[]);
624 /* transform explicitly specified column */
626 int glp_prim_rtest(glp_prob *P, int len, const int ind[],
627 const double val[], int dir, double eps);
628 /* perform primal ratio test */
630 int glp_dual_rtest(glp_prob *P, int len, const int ind[],
631 const double val[], int dir, double eps);
632 /* perform dual ratio test */
634 void glp_analyze_bound(glp_prob *P, int k, double *value1, int *var1,
635 double *value2, int *var2);
636 /* analyze active bound of non-basic variable */
638 void glp_analyze_coef(glp_prob *P, int k, double *coef1, int *var1,
639 double *value1, double *coef2, int *var2, double *value2);
640 /* analyze objective coefficient at basic variable */
642 int glp_ios_reason(glp_tree *T);
643 /* determine reason for calling the callback routine */
645 glp_prob *glp_ios_get_prob(glp_tree *T);
646 /* access the problem object */
648 void glp_ios_tree_size(glp_tree *T, int *a_cnt, int *n_cnt,
650 /* determine size of the branch-and-bound tree */
652 int glp_ios_curr_node(glp_tree *T);
653 /* determine current active subproblem */
655 int glp_ios_next_node(glp_tree *T, int p);
656 /* determine next active subproblem */
658 int glp_ios_prev_node(glp_tree *T, int p);
659 /* determine previous active subproblem */
661 int glp_ios_up_node(glp_tree *T, int p);
662 /* determine parent subproblem */
664 int glp_ios_node_level(glp_tree *T, int p);
665 /* determine subproblem level */
667 double glp_ios_node_bound(glp_tree *T, int p);
668 /* determine subproblem local bound */
670 int glp_ios_best_node(glp_tree *T);
671 /* find active subproblem with best local bound */
673 double glp_ios_mip_gap(glp_tree *T);
674 /* compute relative MIP gap */
676 void *glp_ios_node_data(glp_tree *T, int p);
677 /* access subproblem application-specific data */
679 void glp_ios_row_attr(glp_tree *T, int i, glp_attr *attr);
680 /* retrieve additional row attributes */
682 int glp_ios_pool_size(glp_tree *T);
683 /* determine current size of the cut pool */
685 int glp_ios_add_row(glp_tree *T,
686 const char *name, int klass, int flags, int len, const int ind[],
687 const double val[], int type, double rhs);
688 /* add row (constraint) to the cut pool */
690 void glp_ios_del_row(glp_tree *T, int i);
691 /* remove row (constraint) from the cut pool */
693 void glp_ios_clear_pool(glp_tree *T);
694 /* remove all rows (constraints) from the cut pool */
696 int glp_ios_can_branch(glp_tree *T, int j);
697 /* check if can branch upon specified variable */
699 void glp_ios_branch_upon(glp_tree *T, int j, int sel);
700 /* choose variable to branch upon */
702 void glp_ios_select_node(glp_tree *T, int p);
703 /* select subproblem to continue the search */
705 int glp_ios_heur_sol(glp_tree *T, const double x[]);
706 /* provide solution found by heuristic */
708 void glp_ios_terminate(glp_tree *T);
709 /* terminate the solution process */
711 void glp_init_mpscp(glp_mpscp *parm);
712 /* initialize MPS format control parameters */
714 int glp_read_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
716 /* read problem data in MPS format */
718 int glp_write_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
720 /* write problem data in MPS format */
722 void glp_init_cpxcp(glp_cpxcp *parm);
723 /* initialize CPLEX LP format control parameters */
725 int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
726 /* read problem data in CPLEX LP format */
728 int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
729 /* write problem data in CPLEX LP format */
731 int glp_read_prob(glp_prob *P, int flags, const char *fname);
732 /* read problem data in GLPK format */
734 int glp_write_prob(glp_prob *P, int flags, const char *fname);
735 /* write problem data in GLPK format */
737 glp_tran *glp_mpl_alloc_wksp(void);
738 /* allocate the MathProg translator workspace */
740 int glp_mpl_read_model(glp_tran *tran, const char *fname, int skip);
741 /* read and translate model section */
743 int glp_mpl_read_data(glp_tran *tran, const char *fname);
744 /* read and translate data section */
746 int glp_mpl_generate(glp_tran *tran, const char *fname);
747 /* generate the model */
749 void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob);
750 /* build LP/MIP problem instance from the model */
752 int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol);
753 /* postsolve the model */
755 void glp_mpl_free_wksp(glp_tran *tran);
756 /* free the MathProg translator workspace */
758 int glp_main(int argc, const char *argv[]);
759 /* stand-alone LP/MIP solver */
761 /**********************************************************************/
763 #ifndef GLP_LONG_DEFINED
764 #define GLP_LONG_DEFINED
765 typedef struct { int lo, hi; } glp_long;
766 /* long integer data type */
769 int glp_init_env(void);
770 /* initialize GLPK environment */
772 const char *glp_version(void);
773 /* determine library version */
775 int glp_free_env(void);
776 /* free GLPK environment */
778 void glp_printf(const char *fmt, ...);
779 /* write formatted output to terminal */
781 void glp_vprintf(const char *fmt, va_list arg);
782 /* write formatted output to terminal */
784 int glp_term_out(int flag);
785 /* enable/disable terminal output */
787 void glp_term_hook(int (*func)(void *info, const char *s), void *info);
788 /* install hook to intercept terminal output */
790 int glp_open_tee(const char *fname);
791 /* start copying terminal output to text file */
793 int glp_close_tee(void);
794 /* stop copying terminal output to text file */
796 #ifndef GLP_ERROR_DEFINED
797 #define GLP_ERROR_DEFINED
798 typedef void (*_glp_error)(const char *fmt, ...);
801 #define glp_error glp_error_(__FILE__, __LINE__)
802 _glp_error glp_error_(const char *file, int line);
803 /* display error message and terminate execution */
805 #define glp_assert(expr) \
806 ((void)((expr) || (glp_assert_(#expr, __FILE__, __LINE__), 1)))
807 void glp_assert_(const char *expr, const char *file, int line);
808 /* check for logical condition */
810 void glp_error_hook(void (*func)(void *info), void *info);
811 /* install hook to intercept abnormal termination */
813 void *glp_malloc(int size);
814 /* allocate memory block */
816 void *glp_calloc(int n, int size);
817 /* allocate memory block */
819 void glp_free(void *ptr);
820 /* free memory block */
822 void glp_mem_limit(int limit);
823 /* set memory usage limit */
825 void glp_mem_usage(int *count, int *cpeak, glp_long *total,
827 /* get memory usage information */
829 glp_long glp_time(void);
830 /* determine current universal time */
832 double glp_difftime(glp_long t1, glp_long t0);
833 /* compute difference between two time values */
835 /**********************************************************************/
837 #ifndef GLP_DATA_DEFINED
838 #define GLP_DATA_DEFINED
839 typedef struct { double _opaque_data[100]; } glp_data;
840 /* plain data file */
843 glp_data *glp_sdf_open_file(const char *fname);
844 /* open plain data file */
846 void glp_sdf_set_jump(glp_data *data, void *jump);
847 /* set up error handling */
849 void glp_sdf_error(glp_data *data, const char *fmt, ...);
850 /* print error message */
852 void glp_sdf_warning(glp_data *data, const char *fmt, ...);
853 /* print warning message */
855 int glp_sdf_read_int(glp_data *data);
856 /* read integer number */
858 double glp_sdf_read_num(glp_data *data);
859 /* read floating-point number */
861 const char *glp_sdf_read_item(glp_data *data);
864 const char *glp_sdf_read_text(glp_data *data);
865 /* read text until end of line */
867 int glp_sdf_line(glp_data *data);
868 /* determine current line number */
870 void glp_sdf_close_file(glp_data *data);
871 /* close plain data file */
873 /**********************************************************************/
875 typedef struct _glp_graph glp_graph;
876 typedef struct _glp_vertex glp_vertex;
877 typedef struct _glp_arc glp_arc;
880 { /* graph descriptor */
881 void *pool; /* DMP *pool; */
882 /* memory pool to store graph components */
884 /* graph name (1 to 255 chars); NULL means no name is assigned
887 /* length of the vertex list (enlarged automatically) */
889 /* number of vertices in the graph, 0 <= nv <= nv_max */
891 /* number of arcs in the graph, na >= 0 */
892 glp_vertex **v; /* glp_vertex *v[1+nv_max]; */
893 /* v[i], 1 <= i <= nv, is a pointer to i-th vertex */
894 void *index; /* AVL *index; */
895 /* vertex index to find vertices by their names; NULL means the
896 index does not exist */
898 /* size of data associated with each vertex (0 to 256 bytes) */
900 /* size of data associated with each arc (0 to 256 bytes) */
904 { /* vertex descriptor */
906 /* vertex ordinal number, 1 <= i <= nv */
908 /* vertex name (1 to 255 chars); NULL means no name is assigned
910 void *entry; /* AVLNODE *entry; */
911 /* pointer to corresponding entry in the vertex index; NULL means
912 that either the index does not exist or the vertex has no name
915 /* pointer to data associated with the vertex */
917 /* working pointer */
919 /* pointer to the (unordered) list of incoming arcs */
921 /* pointer to the (unordered) list of outgoing arcs */
925 { /* arc descriptor */
927 /* pointer to the tail endpoint */
929 /* pointer to the head endpoint */
931 /* pointer to data associated with the arc */
933 /* working pointer */
935 /* pointer to previous arc having the same tail endpoint */
937 /* pointer to next arc having the same tail endpoint */
939 /* pointer to previous arc having the same head endpoint */
941 /* pointer to next arc having the same head endpoint */
944 glp_graph *glp_create_graph(int v_size, int a_size);
947 void glp_set_graph_name(glp_graph *G, const char *name);
948 /* assign (change) graph name */
950 int glp_add_vertices(glp_graph *G, int nadd);
951 /* add new vertices to graph */
953 void glp_set_vertex_name(glp_graph *G, int i, const char *name);
954 /* assign (change) vertex name */
956 glp_arc *glp_add_arc(glp_graph *G, int i, int j);
957 /* add new arc to graph */
959 void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
960 /* delete vertices from graph */
962 void glp_del_arc(glp_graph *G, glp_arc *a);
963 /* delete arc from graph */
965 void glp_erase_graph(glp_graph *G, int v_size, int a_size);
966 /* erase graph content */
968 void glp_delete_graph(glp_graph *G);
971 void glp_create_v_index(glp_graph *G);
972 /* create vertex name index */
974 int glp_find_vertex(glp_graph *G, const char *name);
975 /* find vertex by its name */
977 void glp_delete_v_index(glp_graph *G);
978 /* delete vertex name index */
980 int glp_read_graph(glp_graph *G, const char *fname);
981 /* read graph from plain text file */
983 int glp_write_graph(glp_graph *G, const char *fname);
984 /* write graph to plain text file */
986 void glp_mincost_lp(glp_prob *P, glp_graph *G, int names, int v_rhs,
987 int a_low, int a_cap, int a_cost);
988 /* convert minimum cost flow problem to LP */
990 int glp_mincost_okalg(glp_graph *G, int v_rhs, int a_low, int a_cap,
991 int a_cost, double *sol, int a_x, int v_pi);
992 /* find minimum-cost flow with out-of-kilter algorithm */
994 void glp_maxflow_lp(glp_prob *P, glp_graph *G, int names, int s,
996 /* convert maximum flow problem to LP */
998 int glp_maxflow_ffalg(glp_graph *G, int s, int t, int a_cap,
999 double *sol, int a_x, int v_cut);
1000 /* find maximal flow with Ford-Fulkerson algorithm */
1002 int glp_check_asnprob(glp_graph *G, int v_set);
1003 /* check correctness of assignment problem data */
1005 /* assignment problem formulation: */
1006 #define GLP_ASN_MIN 1 /* perfect matching (minimization) */
1007 #define GLP_ASN_MAX 2 /* perfect matching (maximization) */
1008 #define GLP_ASN_MMP 3 /* maximum matching */
1010 int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
1011 int v_set, int a_cost);
1012 /* convert assignment problem to LP */
1014 int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
1015 double *sol, int a_x);
1016 /* solve assignment problem with out-of-kilter algorithm */
1018 int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
1019 /* find bipartite matching of maximum cardinality */
1021 double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
1022 /* solve critical path problem */
1024 int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1025 int a_cost, const char *fname);
1026 /* read min-cost flow problem data in DIMACS format */
1028 int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1029 int a_cost, const char *fname);
1030 /* write min-cost flow problem data in DIMACS format */
1032 int glp_read_maxflow(glp_graph *G, int *s, int *t, int a_cap,
1034 /* read maximum flow problem data in DIMACS format */
1036 int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
1038 /* write maximum flow problem data in DIMACS format */
1040 int glp_read_asnprob(glp_graph *G, int v_set, int a_cost, const char
1042 /* read assignment problem data in DIMACS format */
1044 int glp_write_asnprob(glp_graph *G, int v_set, int a_cost, const char
1046 /* write assignment problem data in DIMACS format */
1048 int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname);
1049 /* read graph in DIMACS clique/coloring format */
1051 int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname);
1052 /* write graph in DIMACS clique/coloring format */
1054 int glp_netgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1055 const int parm[1+15]);
1056 /* Klingman's network problem generator */
1058 int glp_gridgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1059 const int parm[1+14]);
1060 /* grid-like network problem generator */
1062 int glp_rmfgen(glp_graph *G, int *s, int *t, int a_cap,
1063 const int parm[1+5]);
1064 /* Goldfarb's maximum flow problem generator */
1066 int glp_weak_comp(glp_graph *G, int v_num);
1067 /* find all weakly connected components of graph */
1069 int glp_strong_comp(glp_graph *G, int v_num);
1070 /* find all strongly connected components of graph */
1072 int glp_top_sort(glp_graph *G, int v_num);
1073 /* topological sorting of acyclic digraph */
1075 int glp_wclique_exact(glp_graph *G, int v_wgt, double *sol, int v_set);
1076 /* find maximum weight clique with exact algorithm */
1078 /***********************************************************************
1079 * NOTE: All symbols defined below are obsolete and kept here only for
1080 * backward compatibility.
1081 ***********************************************************************/
1083 #define LPX glp_prob
1085 /* problem class: */
1086 #define LPX_LP 100 /* linear programming (LP) */
1087 #define LPX_MIP 101 /* mixed integer programming (MIP) */
1089 /* type of auxiliary/structural variable: */
1090 #define LPX_FR 110 /* free variable */
1091 #define LPX_LO 111 /* variable with lower bound */
1092 #define LPX_UP 112 /* variable with upper bound */
1093 #define LPX_DB 113 /* double-bounded variable */
1094 #define LPX_FX 114 /* fixed variable */
1096 /* optimization direction flag: */
1097 #define LPX_MIN 120 /* minimization */
1098 #define LPX_MAX 121 /* maximization */
1100 /* status of primal basic solution: */
1101 #define LPX_P_UNDEF 132 /* primal solution is undefined */
1102 #define LPX_P_FEAS 133 /* solution is primal feasible */
1103 #define LPX_P_INFEAS 134 /* solution is primal infeasible */
1104 #define LPX_P_NOFEAS 135 /* no primal feasible solution exists */
1106 /* status of dual basic solution: */
1107 #define LPX_D_UNDEF 136 /* dual solution is undefined */
1108 #define LPX_D_FEAS 137 /* solution is dual feasible */
1109 #define LPX_D_INFEAS 138 /* solution is dual infeasible */
1110 #define LPX_D_NOFEAS 139 /* no dual feasible solution exists */
1112 /* status of auxiliary/structural variable: */
1113 #define LPX_BS 140 /* basic variable */
1114 #define LPX_NL 141 /* non-basic variable on lower bound */
1115 #define LPX_NU 142 /* non-basic variable on upper bound */
1116 #define LPX_NF 143 /* non-basic free variable */
1117 #define LPX_NS 144 /* non-basic fixed variable */
1119 /* status of interior-point solution: */
1120 #define LPX_T_UNDEF 150 /* interior solution is undefined */
1121 #define LPX_T_OPT 151 /* interior solution is optimal */
1123 /* kind of structural variable: */
1124 #define LPX_CV 160 /* continuous variable */
1125 #define LPX_IV 161 /* integer variable */
1127 /* status of integer solution: */
1128 #define LPX_I_UNDEF 170 /* integer solution is undefined */
1129 #define LPX_I_OPT 171 /* integer solution is optimal */
1130 #define LPX_I_FEAS 172 /* integer solution is feasible */
1131 #define LPX_I_NOFEAS 173 /* no integer solution exists */
1133 /* status codes reported by the routine lpx_get_status: */
1134 #define LPX_OPT 180 /* optimal */
1135 #define LPX_FEAS 181 /* feasible */
1136 #define LPX_INFEAS 182 /* infeasible */
1137 #define LPX_NOFEAS 183 /* no feasible */
1138 #define LPX_UNBND 184 /* unbounded */
1139 #define LPX_UNDEF 185 /* undefined */
1141 /* exit codes returned by solver routines: */
1142 #define LPX_E_OK 200 /* success */
1143 #define LPX_E_EMPTY 201 /* empty problem */
1144 #define LPX_E_BADB 202 /* invalid initial basis */
1145 #define LPX_E_INFEAS 203 /* infeasible initial solution */
1146 #define LPX_E_FAULT 204 /* unable to start the search */
1147 #define LPX_E_OBJLL 205 /* objective lower limit reached */
1148 #define LPX_E_OBJUL 206 /* objective upper limit reached */
1149 #define LPX_E_ITLIM 207 /* iterations limit exhausted */
1150 #define LPX_E_TMLIM 208 /* time limit exhausted */
1151 #define LPX_E_NOFEAS 209 /* no feasible solution */
1152 #define LPX_E_INSTAB 210 /* numerical instability */
1153 #define LPX_E_SING 211 /* problems with basis matrix */
1154 #define LPX_E_NOCONV 212 /* no convergence (interior) */
1155 #define LPX_E_NOPFS 213 /* no primal feas. sol. (LP presolver) */
1156 #define LPX_E_NODFS 214 /* no dual feas. sol. (LP presolver) */
1157 #define LPX_E_MIPGAP 215 /* relative mip gap tolerance reached */
1159 /* control parameter identifiers: */
1160 #define LPX_K_MSGLEV 300 /* lp->msg_lev */
1161 #define LPX_K_SCALE 301 /* lp->scale */
1162 #define LPX_K_DUAL 302 /* lp->dual */
1163 #define LPX_K_PRICE 303 /* lp->price */
1164 #define LPX_K_RELAX 304 /* lp->relax */
1165 #define LPX_K_TOLBND 305 /* lp->tol_bnd */
1166 #define LPX_K_TOLDJ 306 /* lp->tol_dj */
1167 #define LPX_K_TOLPIV 307 /* lp->tol_piv */
1168 #define LPX_K_ROUND 308 /* lp->round */
1169 #define LPX_K_OBJLL 309 /* lp->obj_ll */
1170 #define LPX_K_OBJUL 310 /* lp->obj_ul */
1171 #define LPX_K_ITLIM 311 /* lp->it_lim */
1172 #define LPX_K_ITCNT 312 /* lp->it_cnt */
1173 #define LPX_K_TMLIM 313 /* lp->tm_lim */
1174 #define LPX_K_OUTFRQ 314 /* lp->out_frq */
1175 #define LPX_K_OUTDLY 315 /* lp->out_dly */
1176 #define LPX_K_BRANCH 316 /* lp->branch */
1177 #define LPX_K_BTRACK 317 /* lp->btrack */
1178 #define LPX_K_TOLINT 318 /* lp->tol_int */
1179 #define LPX_K_TOLOBJ 319 /* lp->tol_obj */
1180 #define LPX_K_MPSINFO 320 /* lp->mps_info */
1181 #define LPX_K_MPSOBJ 321 /* lp->mps_obj */
1182 #define LPX_K_MPSORIG 322 /* lp->mps_orig */
1183 #define LPX_K_MPSWIDE 323 /* lp->mps_wide */
1184 #define LPX_K_MPSFREE 324 /* lp->mps_free */
1185 #define LPX_K_MPSSKIP 325 /* lp->mps_skip */
1186 #define LPX_K_LPTORIG 326 /* lp->lpt_orig */
1187 #define LPX_K_PRESOL 327 /* lp->presol */
1188 #define LPX_K_BINARIZE 328 /* lp->binarize */
1189 #define LPX_K_USECUTS 329 /* lp->use_cuts */
1190 #define LPX_K_BFTYPE 330 /* lp->bfcp->type */
1191 #define LPX_K_MIPGAP 331 /* lp->mip_gap */
1193 #define LPX_C_COVER 0x01 /* mixed cover cuts */
1194 #define LPX_C_CLIQUE 0x02 /* clique cuts */
1195 #define LPX_C_GOMORY 0x04 /* Gomory's mixed integer cuts */
1196 #define LPX_C_MIR 0x08 /* mixed integer rounding cuts */
1197 #define LPX_C_ALL 0xFF /* all cuts */
1200 { /* this structure contains results reported by the routines which
1201 checks Karush-Kuhn-Tucker conditions (for details see comments
1202 to those routines) */
1203 /*--------------------------------------------------------------*/
1204 /* xR - A * xS = 0 (KKT.PE) */
1206 /* largest absolute error */
1208 /* number of row with largest absolute error */
1210 /* largest relative error */
1212 /* number of row with largest relative error */
1214 /* quality of primal solution:
1218 '?' - primal solution is wrong */
1219 /*--------------------------------------------------------------*/
1220 /* l[k] <= x[k] <= u[k] (KKT.PB) */
1222 /* largest absolute error */
1224 /* number of variable with largest absolute error */
1226 /* largest relative error */
1228 /* number of variable with largest relative error */
1230 /* quality of primal feasibility:
1234 '?' - primal solution is infeasible */
1235 /*--------------------------------------------------------------*/
1236 /* A' * (dR - cR) + (dS - cS) = 0 (KKT.DE) */
1238 /* largest absolute error */
1240 /* number of column with largest absolute error */
1242 /* largest relative error */
1244 /* number of column with largest relative error */
1246 /* quality of dual solution:
1250 '?' - dual solution is wrong */
1251 /*--------------------------------------------------------------*/
1252 /* d[k] >= 0 or d[k] <= 0 (KKT.DB) */
1254 /* largest absolute error */
1256 /* number of variable with largest absolute error */
1258 /* largest relative error */
1260 /* number of variable with largest relative error */
1262 /* quality of dual feasibility:
1266 '?' - dual solution is infeasible */
1267 /*--------------------------------------------------------------*/
1268 /* (x[k] - bound of x[k]) * d[k] = 0 (KKT.CS) */
1270 /* largest absolute error */
1272 /* number of variable with largest absolute error */
1274 /* largest relative error */
1276 /* number of variable with largest relative error */
1278 /* quality of complementary slackness:
1282 '?' - primal and dual solutions are not complementary */
1285 #define lpx_create_prob _glp_lpx_create_prob
1286 LPX *lpx_create_prob(void);
1287 /* create problem object */
1289 #define lpx_set_prob_name _glp_lpx_set_prob_name
1290 void lpx_set_prob_name(LPX *lp, const char *name);
1291 /* assign (change) problem name */
1293 #define lpx_set_obj_name _glp_lpx_set_obj_name
1294 void lpx_set_obj_name(LPX *lp, const char *name);
1295 /* assign (change) objective function name */
1297 #define lpx_set_obj_dir _glp_lpx_set_obj_dir
1298 void lpx_set_obj_dir(LPX *lp, int dir);
1299 /* set (change) optimization direction flag */
1301 #define lpx_add_rows _glp_lpx_add_rows
1302 int lpx_add_rows(LPX *lp, int nrs);
1303 /* add new rows to problem object */
1305 #define lpx_add_cols _glp_lpx_add_cols
1306 int lpx_add_cols(LPX *lp, int ncs);
1307 /* add new columns to problem object */
1309 #define lpx_set_row_name _glp_lpx_set_row_name
1310 void lpx_set_row_name(LPX *lp, int i, const char *name);
1311 /* assign (change) row name */
1313 #define lpx_set_col_name _glp_lpx_set_col_name
1314 void lpx_set_col_name(LPX *lp, int j, const char *name);
1315 /* assign (change) column name */
1317 #define lpx_set_row_bnds _glp_lpx_set_row_bnds
1318 void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub);
1319 /* set (change) row bounds */
1321 #define lpx_set_col_bnds _glp_lpx_set_col_bnds
1322 void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub);
1323 /* set (change) column bounds */
1325 #define lpx_set_obj_coef _glp_lpx_set_obj_coef
1326 void lpx_set_obj_coef(glp_prob *lp, int j, double coef);
1327 /* set (change) obj. coefficient or constant term */
1329 #define lpx_set_mat_row _glp_lpx_set_mat_row
1330 void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
1331 const double val[]);
1332 /* set (replace) row of the constraint matrix */
1334 #define lpx_set_mat_col _glp_lpx_set_mat_col
1335 void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
1336 const double val[]);
1337 /* set (replace) column of the constraint matrix */
1339 #define lpx_load_matrix _glp_lpx_load_matrix
1340 void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
1342 /* load (replace) the whole constraint matrix */
1344 #define lpx_del_rows _glp_lpx_del_rows
1345 void lpx_del_rows(LPX *lp, int nrs, const int num[]);
1346 /* delete specified rows from problem object */
1348 #define lpx_del_cols _glp_lpx_del_cols
1349 void lpx_del_cols(LPX *lp, int ncs, const int num[]);
1350 /* delete specified columns from problem object */
1352 #define lpx_delete_prob _glp_lpx_delete_prob
1353 void lpx_delete_prob(LPX *lp);
1354 /* delete problem object */
1356 #define lpx_get_prob_name _glp_lpx_get_prob_name
1357 const char *lpx_get_prob_name(LPX *lp);
1358 /* retrieve problem name */
1360 #define lpx_get_obj_name _glp_lpx_get_obj_name
1361 const char *lpx_get_obj_name(LPX *lp);
1362 /* retrieve objective function name */
1364 #define lpx_get_obj_dir _glp_lpx_get_obj_dir
1365 int lpx_get_obj_dir(LPX *lp);
1366 /* retrieve optimization direction flag */
1368 #define lpx_get_num_rows _glp_lpx_get_num_rows
1369 int lpx_get_num_rows(LPX *lp);
1370 /* retrieve number of rows */
1372 #define lpx_get_num_cols _glp_lpx_get_num_cols
1373 int lpx_get_num_cols(LPX *lp);
1374 /* retrieve number of columns */
1376 #define lpx_get_row_name _glp_lpx_get_row_name
1377 const char *lpx_get_row_name(LPX *lp, int i);
1378 /* retrieve row name */
1380 #define lpx_get_col_name _glp_lpx_get_col_name
1381 const char *lpx_get_col_name(LPX *lp, int j);
1382 /* retrieve column name */
1384 #define lpx_get_row_type _glp_lpx_get_row_type
1385 int lpx_get_row_type(LPX *lp, int i);
1386 /* retrieve row type */
1388 #define lpx_get_row_lb _glp_lpx_get_row_lb
1389 double lpx_get_row_lb(LPX *lp, int i);
1390 /* retrieve row lower bound */
1392 #define lpx_get_row_ub _glp_lpx_get_row_ub
1393 double lpx_get_row_ub(LPX *lp, int i);
1394 /* retrieve row upper bound */
1396 #define lpx_get_row_bnds _glp_lpx_get_row_bnds
1397 void lpx_get_row_bnds(LPX *lp, int i, int *typx, double *lb,
1399 /* retrieve row bounds */
1401 #define lpx_get_col_type _glp_lpx_get_col_type
1402 int lpx_get_col_type(LPX *lp, int j);
1403 /* retrieve column type */
1405 #define lpx_get_col_lb _glp_lpx_get_col_lb
1406 double lpx_get_col_lb(LPX *lp, int j);
1407 /* retrieve column lower bound */
1409 #define lpx_get_col_ub _glp_lpx_get_col_ub
1410 double lpx_get_col_ub(LPX *lp, int j);
1411 /* retrieve column upper bound */
1413 #define lpx_get_col_bnds _glp_lpx_get_col_bnds
1414 void lpx_get_col_bnds(LPX *lp, int j, int *typx, double *lb,
1416 /* retrieve column bounds */
1418 #define lpx_get_obj_coef _glp_lpx_get_obj_coef
1419 double lpx_get_obj_coef(LPX *lp, int j);
1420 /* retrieve obj. coefficient or constant term */
1422 #define lpx_get_num_nz _glp_lpx_get_num_nz
1423 int lpx_get_num_nz(LPX *lp);
1424 /* retrieve number of constraint coefficients */
1426 #define lpx_get_mat_row _glp_lpx_get_mat_row
1427 int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[]);
1428 /* retrieve row of the constraint matrix */
1430 #define lpx_get_mat_col _glp_lpx_get_mat_col
1431 int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[]);
1432 /* retrieve column of the constraint matrix */
1434 #define lpx_create_index _glp_lpx_create_index
1435 void lpx_create_index(LPX *lp);
1436 /* create the name index */
1438 #define lpx_find_row _glp_lpx_find_row
1439 int lpx_find_row(LPX *lp, const char *name);
1440 /* find row by its name */
1442 #define lpx_find_col _glp_lpx_find_col
1443 int lpx_find_col(LPX *lp, const char *name);
1444 /* find column by its name */
1446 #define lpx_delete_index _glp_lpx_delete_index
1447 void lpx_delete_index(LPX *lp);
1448 /* delete the name index */
1450 #define lpx_scale_prob _glp_lpx_scale_prob
1451 void lpx_scale_prob(LPX *lp);
1452 /* scale problem data */
1454 #define lpx_unscale_prob _glp_lpx_unscale_prob
1455 void lpx_unscale_prob(LPX *lp);
1456 /* unscale problem data */
1458 #define lpx_set_row_stat _glp_lpx_set_row_stat
1459 void lpx_set_row_stat(LPX *lp, int i, int stat);
1460 /* set (change) row status */
1462 #define lpx_set_col_stat _glp_lpx_set_col_stat
1463 void lpx_set_col_stat(LPX *lp, int j, int stat);
1464 /* set (change) column status */
1466 #define lpx_std_basis _glp_lpx_std_basis
1467 void lpx_std_basis(LPX *lp);
1468 /* construct standard initial LP basis */
1470 #define lpx_adv_basis _glp_lpx_adv_basis
1471 void lpx_adv_basis(LPX *lp);
1472 /* construct advanced initial LP basis */
1474 #define lpx_cpx_basis _glp_lpx_cpx_basis
1475 void lpx_cpx_basis(LPX *lp);
1476 /* construct Bixby's initial LP basis */
1478 #define lpx_simplex _glp_lpx_simplex
1479 int lpx_simplex(LPX *lp);
1480 /* easy-to-use driver to the simplex method */
1482 #define lpx_exact _glp_lpx_exact
1483 int lpx_exact(LPX *lp);
1484 /* easy-to-use driver to the exact simplex method */
1486 #define lpx_get_status _glp_lpx_get_status
1487 int lpx_get_status(LPX *lp);
1488 /* retrieve generic status of basic solution */
1490 #define lpx_get_prim_stat _glp_lpx_get_prim_stat
1491 int lpx_get_prim_stat(LPX *lp);
1492 /* retrieve primal status of basic solution */
1494 #define lpx_get_dual_stat _glp_lpx_get_dual_stat
1495 int lpx_get_dual_stat(LPX *lp);
1496 /* retrieve dual status of basic solution */
1498 #define lpx_get_obj_val _glp_lpx_get_obj_val
1499 double lpx_get_obj_val(LPX *lp);
1500 /* retrieve objective value (basic solution) */
1502 #define lpx_get_row_stat _glp_lpx_get_row_stat
1503 int lpx_get_row_stat(LPX *lp, int i);
1504 /* retrieve row status (basic solution) */
1506 #define lpx_get_row_prim _glp_lpx_get_row_prim
1507 double lpx_get_row_prim(LPX *lp, int i);
1508 /* retrieve row primal value (basic solution) */
1510 #define lpx_get_row_dual _glp_lpx_get_row_dual
1511 double lpx_get_row_dual(LPX *lp, int i);
1512 /* retrieve row dual value (basic solution) */
1514 #define lpx_get_row_info _glp_lpx_get_row_info
1515 void lpx_get_row_info(LPX *lp, int i, int *tagx, double *vx,
1517 /* obtain row solution information */
1519 #define lpx_get_col_stat _glp_lpx_get_col_stat
1520 int lpx_get_col_stat(LPX *lp, int j);
1521 /* retrieve column status (basic solution) */
1523 #define lpx_get_col_prim _glp_lpx_get_col_prim
1524 double lpx_get_col_prim(LPX *lp, int j);
1525 /* retrieve column primal value (basic solution) */
1527 #define lpx_get_col_dual _glp_lpx_get_col_dual
1528 double lpx_get_col_dual(glp_prob *lp, int j);
1529 /* retrieve column dual value (basic solution) */
1531 #define lpx_get_col_info _glp_lpx_get_col_info
1532 void lpx_get_col_info(LPX *lp, int j, int *tagx, double *vx,
1534 /* obtain column solution information (obsolete) */
1536 #define lpx_get_ray_info _glp_lpx_get_ray_info
1537 int lpx_get_ray_info(LPX *lp);
1538 /* determine what causes primal unboundness */
1540 #define lpx_check_kkt _glp_lpx_check_kkt
1541 void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt);
1542 /* check Karush-Kuhn-Tucker conditions */
1544 #define lpx_warm_up _glp_lpx_warm_up
1545 int lpx_warm_up(LPX *lp);
1546 /* "warm up" LP basis */
1548 #define lpx_eval_tab_row _glp_lpx_eval_tab_row
1549 int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[]);
1550 /* compute row of the simplex table */
1552 #define lpx_eval_tab_col _glp_lpx_eval_tab_col
1553 int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[]);
1554 /* compute column of the simplex table */
1556 #define lpx_transform_row _glp_lpx_transform_row
1557 int lpx_transform_row(LPX *lp, int len, int ind[], double val[]);
1558 /* transform explicitly specified row */
1560 #define lpx_transform_col _glp_lpx_transform_col
1561 int lpx_transform_col(LPX *lp, int len, int ind[], double val[]);
1562 /* transform explicitly specified column */
1564 #define lpx_prim_ratio_test _glp_lpx_prim_ratio_test
1565 int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
1566 const double val[], int how, double tol);
1567 /* perform primal ratio test */
1569 #define lpx_dual_ratio_test _glp_lpx_dual_ratio_test
1570 int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
1571 const double val[], int how, double tol);
1572 /* perform dual ratio test */
1574 #define lpx_interior _glp_lpx_interior
1575 int lpx_interior(LPX *lp);
1576 /* easy-to-use driver to the interior point method */
1578 #define lpx_ipt_status _glp_lpx_ipt_status
1579 int lpx_ipt_status(LPX *lp);
1580 /* retrieve status of interior-point solution */
1582 #define lpx_ipt_obj_val _glp_lpx_ipt_obj_val
1583 double lpx_ipt_obj_val(LPX *lp);
1584 /* retrieve objective value (interior point) */
1586 #define lpx_ipt_row_prim _glp_lpx_ipt_row_prim
1587 double lpx_ipt_row_prim(LPX *lp, int i);
1588 /* retrieve row primal value (interior point) */
1590 #define lpx_ipt_row_dual _glp_lpx_ipt_row_dual
1591 double lpx_ipt_row_dual(LPX *lp, int i);
1592 /* retrieve row dual value (interior point) */
1594 #define lpx_ipt_col_prim _glp_lpx_ipt_col_prim
1595 double lpx_ipt_col_prim(LPX *lp, int j);
1596 /* retrieve column primal value (interior point) */
1598 #define lpx_ipt_col_dual _glp_lpx_ipt_col_dual
1599 double lpx_ipt_col_dual(LPX *lp, int j);
1600 /* retrieve column dual value (interior point) */
1602 #define lpx_set_class _glp_lpx_set_class
1603 void lpx_set_class(LPX *lp, int klass);
1604 /* set problem class */
1606 #define lpx_get_class _glp_lpx_get_class
1607 int lpx_get_class(LPX *lp);
1608 /* determine problem klass */
1610 #define lpx_set_col_kind _glp_lpx_set_col_kind
1611 void lpx_set_col_kind(LPX *lp, int j, int kind);
1612 /* set (change) column kind */
1614 #define lpx_get_col_kind _glp_lpx_get_col_kind
1615 int lpx_get_col_kind(LPX *lp, int j);
1616 /* retrieve column kind */
1618 #define lpx_get_num_int _glp_lpx_get_num_int
1619 int lpx_get_num_int(LPX *lp);
1620 /* retrieve number of integer columns */
1622 #define lpx_get_num_bin _glp_lpx_get_num_bin
1623 int lpx_get_num_bin(LPX *lp);
1624 /* retrieve number of binary columns */
1626 #define lpx_integer _glp_lpx_integer
1627 int lpx_integer(LPX *lp);
1628 /* easy-to-use driver to the branch-and-bound method */
1630 #define lpx_intopt _glp_lpx_intopt
1631 int lpx_intopt(LPX *lp);
1632 /* easy-to-use driver to the branch-and-bound method */
1634 #define lpx_mip_status _glp_lpx_mip_status
1635 int lpx_mip_status(LPX *lp);
1636 /* retrieve status of MIP solution */
1638 #define lpx_mip_obj_val _glp_lpx_mip_obj_val
1639 double lpx_mip_obj_val(LPX *lp);
1640 /* retrieve objective value (MIP solution) */
1642 #define lpx_mip_row_val _glp_lpx_mip_row_val
1643 double lpx_mip_row_val(LPX *lp, int i);
1644 /* retrieve row value (MIP solution) */
1646 #define lpx_mip_col_val _glp_lpx_mip_col_val
1647 double lpx_mip_col_val(LPX *lp, int j);
1648 /* retrieve column value (MIP solution) */
1650 #define lpx_check_int _glp_lpx_check_int
1651 void lpx_check_int(LPX *lp, LPXKKT *kkt);
1652 /* check integer feasibility conditions */
1654 #define lpx_reset_parms _glp_lpx_reset_parms
1655 void lpx_reset_parms(LPX *lp);
1656 /* reset control parameters to default values */
1658 #define lpx_set_int_parm _glp_lpx_set_int_parm
1659 void lpx_set_int_parm(LPX *lp, int parm, int val);
1660 /* set (change) integer control parameter */
1662 #define lpx_get_int_parm _glp_lpx_get_int_parm
1663 int lpx_get_int_parm(LPX *lp, int parm);
1664 /* query integer control parameter */
1666 #define lpx_set_real_parm _glp_lpx_set_real_parm
1667 void lpx_set_real_parm(LPX *lp, int parm, double val);
1668 /* set (change) real control parameter */
1670 #define lpx_get_real_parm _glp_lpx_get_real_parm
1671 double lpx_get_real_parm(LPX *lp, int parm);
1672 /* query real control parameter */
1674 #define lpx_read_mps _glp_lpx_read_mps
1675 LPX *lpx_read_mps(const char *fname);
1676 /* read problem data in fixed MPS format */
1678 #define lpx_write_mps _glp_lpx_write_mps
1679 int lpx_write_mps(LPX *lp, const char *fname);
1680 /* write problem data in fixed MPS format */
1682 #define lpx_read_bas _glp_lpx_read_bas
1683 int lpx_read_bas(LPX *lp, const char *fname);
1684 /* read LP basis in fixed MPS format */
1686 #define lpx_write_bas _glp_lpx_write_bas
1687 int lpx_write_bas(LPX *lp, const char *fname);
1688 /* write LP basis in fixed MPS format */
1690 #define lpx_read_freemps _glp_lpx_read_freemps
1691 LPX *lpx_read_freemps(const char *fname);
1692 /* read problem data in free MPS format */
1694 #define lpx_write_freemps _glp_lpx_write_freemps
1695 int lpx_write_freemps(LPX *lp, const char *fname);
1696 /* write problem data in free MPS format */
1698 #define lpx_read_cpxlp _glp_lpx_read_cpxlp
1699 LPX *lpx_read_cpxlp(const char *fname);
1700 /* read problem data in CPLEX LP format */
1702 #define lpx_write_cpxlp _glp_lpx_write_cpxlp
1703 int lpx_write_cpxlp(LPX *lp, const char *fname);
1704 /* write problem data in CPLEX LP format */
1706 #define lpx_read_model _glp_lpx_read_model
1707 LPX *lpx_read_model(const char *model, const char *data,
1708 const char *output);
1709 /* read LP/MIP model written in GNU MathProg language */
1711 #define lpx_print_prob _glp_lpx_print_prob
1712 int lpx_print_prob(LPX *lp, const char *fname);
1713 /* write problem data in plain text format */
1715 #define lpx_print_sol _glp_lpx_print_sol
1716 int lpx_print_sol(LPX *lp, const char *fname);
1717 /* write LP problem solution in printable format */
1719 #define lpx_print_sens_bnds _glp_lpx_print_sens_bnds
1720 int lpx_print_sens_bnds(LPX *lp, const char *fname);
1721 /* write bounds sensitivity information */
1723 #define lpx_print_ips _glp_lpx_print_ips
1724 int lpx_print_ips(LPX *lp, const char *fname);
1725 /* write interior point solution in printable format */
1727 #define lpx_print_mip _glp_lpx_print_mip
1728 int lpx_print_mip(LPX *lp, const char *fname);
1729 /* write MIP problem solution in printable format */
1731 #define lpx_is_b_avail _glp_lpx_is_b_avail
1732 int lpx_is_b_avail(LPX *lp);
1733 /* check if LP basis is available */
1735 #define lpx_write_pb _glp_lpx_write_pb
1736 int lpx_write_pb(LPX *lp, const char *fname, int normalized,
1738 /* write problem data in (normalized) OPB format */
1740 #define lpx_main _glp_lpx_main
1741 int lpx_main(int argc, const char *argv[]);
1742 /* stand-alone LP/MIP solver */