Context Navigation

glpk.h @ 9:33de93886c88

subpack-glpk

Last change on this file since 9:33de93886c88 was 9:33de93886c88, checked in by Alpar Juttner <alpar@…>, 13 years ago
Import GLPK 4.47
File size: 59.2 KB

Line
1	/* glpk.h */
2
3	/***********************************************************************
4	* This code is part of GLPK (GNU Linear Programming Kit).
5	*
6	* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7	* 2009, 2010, 2011 Andrew Makhorin, Department for Applied Informatics,
8	* Moscow Aviation Institute, Moscow, Russia. All rights reserved.
9	* E-mail: <mao@gnu.org>.
10	*
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.
15	*
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.
20	*
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	***********************************************************************/
24
25	#ifndef GLPK_H
26	#define GLPK_H
27
28	#include <stdarg.h>
29	#include <stddef.h>
30
31	#ifdef __cplusplus
32	extern "C" {
33	#endif
34
35	/* library version numbers: */
36	#define GLP_MAJOR_VERSION 4
37	#define GLP_MINOR_VERSION 47
38
39	#ifndef GLP_PROB_DEFINED
40	#define GLP_PROB_DEFINED
41	typedef struct { double _opaque_prob[100]; } glp_prob;
42	/* LP/MIP problem object */
43	#endif
44
45	/* optimization direction flag: */
46	#define GLP_MIN 1 /* minimization */
47	#define GLP_MAX 2 /* maximization */
48
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 */
53
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 */
60
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 */
67
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 */
74
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 */
79
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 */
87
88	typedef struct
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) */
106	} glp_bfcp;
107
108	typedef struct
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) */
137	} glp_smcp;
138
139	typedef struct
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) */
148	} glp_iptcp;
149
150	#ifndef GLP_TREE_DEFINED
151	#define GLP_TREE_DEFINED
152	typedef struct { double _opaque_tree[100]; } glp_tree;
153	/* branch-and-bound tree */
154	#endif
155
156	typedef struct
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);
176	/* mip.cb_func */
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 */
193	#endif
194	double foo_bar[29]; /* (reserved) */
195	} glp_iocp;
196
197	typedef struct
198	{ /* additional row attributes */
199	int level;
200	/* subproblem level at which the row was added */
201	int origin;
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 */
206	int klass;
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 */
212	double foo_bar[7];
213	/* (reserved) */
214	} glp_attr;
215
216	/* enable/disable flag: */
217	#define GLP_ON 1 /* enable something */
218	#define GLP_OFF 0 /* disable something */
219
220	/* reason codes: */
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 */
228
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 */
233
234	/* return codes: */
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 */
254
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 */
261
262	/* MPS file format: */
263	#define GLP_MPS_DECK 1 /* fixed (ancient) */
264	#define GLP_MPS_FILE 2 /* free (modern) */
265
266	typedef struct
267	{ /* MPS format control parameters */
268	int blank;
269	/* character code to replace blanks in symbolic names */
270	char *obj_name;
271	/* objective row name */
272	double tol_mps;
273	/* zero tolerance for MPS data */
274	double foo_bar[17];
275	/* (reserved for use in the future) */
276	} glp_mpscp;
277
278	typedef struct
279	{ /* CPLEX LP format control parameters */
280	double foo_bar[20];
281	/* (reserved for use in the future) */
282	} glp_cpxcp;
283
284	#ifndef GLP_TRAN_DEFINED
285	#define GLP_TRAN_DEFINED
286	typedef struct { double _opaque_tran[100]; } glp_tran;
287	/* MathProg translator workspace */
288	#endif
289
290	glp_prob *glp_create_prob(void);
291	/* create problem object */
292
293	void glp_set_prob_name(glp_prob P, const char name);
294	/* assign (change) problem name */
295
296	void glp_set_obj_name(glp_prob P, const char name);
297	/* assign (change) objective function name */
298
299	void glp_set_obj_dir(glp_prob *P, int dir);
300	/* set (change) optimization direction flag */
301
302	int glp_add_rows(glp_prob *P, int nrs);
303	/* add new rows to problem object */
304
305	int glp_add_cols(glp_prob *P, int ncs);
306	/* add new columns to problem object */
307
308	void glp_set_row_name(glp_prob P, int i, const char name);
309	/* assign (change) row name */
310
311	void glp_set_col_name(glp_prob P, int j, const char name);
312	/* assign (change) column name */
313
314	void glp_set_row_bnds(glp_prob *P, int i, int type, double lb,
315	double ub);
316	/* set (change) row bounds */
317
318	void glp_set_col_bnds(glp_prob *P, int j, int type, double lb,
319	double ub);
320	/* set (change) column bounds */
321
322	void glp_set_obj_coef(glp_prob *P, int j, double coef);
323	/* set (change) obj. coefficient or constant term */
324
325	void glp_set_mat_row(glp_prob *P, int i, int len, const int ind[],
326	const double val[]);
327	/* set (replace) row of the constraint matrix */
328
329	void glp_set_mat_col(glp_prob *P, int j, int len, const int ind[],
330	const double val[]);
331	/* set (replace) column of the constraint matrix */
332
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 */
336
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 */
339
340	void glp_sort_matrix(glp_prob *P);
341	/* sort elements of the constraint matrix */
342
343	void glp_del_rows(glp_prob *P, int nrs, const int num[]);
344	/* delete specified rows from problem object */
345
346	void glp_del_cols(glp_prob *P, int ncs, const int num[]);
347	/* delete specified columns from problem object */
348
349	void glp_copy_prob(glp_prob dest, glp_prob prob, int names);
350	/* copy problem object content */
351
352	void glp_erase_prob(glp_prob *P);
353	/* erase problem object content */
354
355	void glp_delete_prob(glp_prob *P);
356	/* delete problem object */
357
358	const char glp_get_prob_name(glp_prob P);
359	/* retrieve problem name */
360
361	const char glp_get_obj_name(glp_prob P);
362	/* retrieve objective function name */
363
364	int glp_get_obj_dir(glp_prob *P);
365	/* retrieve optimization direction flag */
366
367	int glp_get_num_rows(glp_prob *P);
368	/* retrieve number of rows */
369
370	int glp_get_num_cols(glp_prob *P);
371	/* retrieve number of columns */
372
373	const char glp_get_row_name(glp_prob P, int i);
374	/* retrieve row name */
375
376	const char glp_get_col_name(glp_prob P, int j);
377	/* retrieve column name */
378
379	int glp_get_row_type(glp_prob *P, int i);
380	/* retrieve row type */
381
382	double glp_get_row_lb(glp_prob *P, int i);
383	/* retrieve row lower bound */
384
385	double glp_get_row_ub(glp_prob *P, int i);
386	/* retrieve row upper bound */
387
388	int glp_get_col_type(glp_prob *P, int j);
389	/* retrieve column type */
390
391	double glp_get_col_lb(glp_prob *P, int j);
392	/* retrieve column lower bound */
393
394	double glp_get_col_ub(glp_prob *P, int j);
395	/* retrieve column upper bound */
396
397	double glp_get_obj_coef(glp_prob *P, int j);
398	/* retrieve obj. coefficient or constant term */
399
400	int glp_get_num_nz(glp_prob *P);
401	/* retrieve number of constraint coefficients */
402
403	int glp_get_mat_row(glp_prob *P, int i, int ind[], double val[]);
404	/* retrieve row of the constraint matrix */
405
406	int glp_get_mat_col(glp_prob *P, int j, int ind[], double val[]);
407	/* retrieve column of the constraint matrix */
408
409	void glp_create_index(glp_prob *P);
410	/* create the name index */
411
412	int glp_find_row(glp_prob P, const char name);
413	/* find row by its name */
414
415	int glp_find_col(glp_prob P, const char name);
416	/* find column by its name */
417
418	void glp_delete_index(glp_prob *P);
419	/* delete the name index */
420
421	void glp_set_rii(glp_prob *P, int i, double rii);
422	/* set (change) row scale factor */
423
424	void glp_set_sjj(glp_prob *P, int j, double sjj);
425	/* set (change) column scale factor */
426
427	double glp_get_rii(glp_prob *P, int i);
428	/* retrieve row scale factor */
429
430	double glp_get_sjj(glp_prob *P, int j);
431	/* retrieve column scale factor */
432
433	void glp_scale_prob(glp_prob *P, int flags);
434	/* scale problem data */
435
436	void glp_unscale_prob(glp_prob *P);
437	/* unscale problem data */
438
439	void glp_set_row_stat(glp_prob *P, int i, int stat);
440	/* set (change) row status */
441
442	void glp_set_col_stat(glp_prob *P, int j, int stat);
443	/* set (change) column status */
444
445	void glp_std_basis(glp_prob *P);
446	/* construct standard initial LP basis */
447
448	void glp_adv_basis(glp_prob *P, int flags);
449	/* construct advanced initial LP basis */
450
451	void glp_cpx_basis(glp_prob *P);
452	/* construct Bixby's initial LP basis */
453
454	int glp_simplex(glp_prob P, const glp_smcp parm);
455	/* solve LP problem with the simplex method */
456
457	int glp_exact(glp_prob P, const glp_smcp parm);
458	/* solve LP problem in exact arithmetic */
459
460	void glp_init_smcp(glp_smcp *parm);
461	/* initialize simplex method control parameters */
462
463	int glp_get_status(glp_prob *P);
464	/* retrieve generic status of basic solution */
465
466	int glp_get_prim_stat(glp_prob *P);
467	/* retrieve status of primal basic solution */
468
469	int glp_get_dual_stat(glp_prob *P);
470	/* retrieve status of dual basic solution */
471
472	double glp_get_obj_val(glp_prob *P);
473	/* retrieve objective value (basic solution) */
474
475	int glp_get_row_stat(glp_prob *P, int i);
476	/* retrieve row status */
477
478	double glp_get_row_prim(glp_prob *P, int i);
479	/* retrieve row primal value (basic solution) */
480
481	double glp_get_row_dual(glp_prob *P, int i);
482	/* retrieve row dual value (basic solution) */
483
484	int glp_get_col_stat(glp_prob *P, int j);
485	/* retrieve column status */
486
487	double glp_get_col_prim(glp_prob *P, int j);
488	/* retrieve column primal value (basic solution) */
489
490	double glp_get_col_dual(glp_prob *P, int j);
491	/* retrieve column dual value (basic solution) */
492
493	int glp_get_unbnd_ray(glp_prob *P);
494	/* determine variable causing unboundedness */
495
496	int glp_interior(glp_prob P, const glp_iptcp parm);
497	/* solve LP problem with the interior-point method */
498
499	void glp_init_iptcp(glp_iptcp *parm);
500	/* initialize interior-point solver control parameters */
501
502	int glp_ipt_status(glp_prob *P);
503	/* retrieve status of interior-point solution */
504
505	double glp_ipt_obj_val(glp_prob *P);
506	/* retrieve objective value (interior point) */
507
508	double glp_ipt_row_prim(glp_prob *P, int i);
509	/* retrieve row primal value (interior point) */
510
511	double glp_ipt_row_dual(glp_prob *P, int i);
512	/* retrieve row dual value (interior point) */
513
514	double glp_ipt_col_prim(glp_prob *P, int j);
515	/* retrieve column primal value (interior point) */
516
517	double glp_ipt_col_dual(glp_prob *P, int j);
518	/* retrieve column dual value (interior point) */
519
520	void glp_set_col_kind(glp_prob *P, int j, int kind);
521	/* set (change) column kind */
522
523	int glp_get_col_kind(glp_prob *P, int j);
524	/* retrieve column kind */
525
526	int glp_get_num_int(glp_prob *P);
527	/* retrieve number of integer columns */
528
529	int glp_get_num_bin(glp_prob *P);
530	/* retrieve number of binary columns */
531
532	int glp_intopt(glp_prob P, const glp_iocp parm);
533	/* solve MIP problem with the branch-and-bound method */
534
535	void glp_init_iocp(glp_iocp *parm);
536	/* initialize integer optimizer control parameters */
537
538	int glp_mip_status(glp_prob *P);
539	/* retrieve status of MIP solution */
540
541	double glp_mip_obj_val(glp_prob *P);
542	/* retrieve objective value (MIP solution) */
543
544	double glp_mip_row_val(glp_prob *P, int i);
545	/* retrieve row value (MIP solution) */
546
547	double glp_mip_col_val(glp_prob *P, int j);
548	/* retrieve column value (MIP solution) */
549
550	int glp_print_sol(glp_prob P, const char fname);
551	/* write basic solution in printable format */
552
553	int glp_read_sol(glp_prob P, const char fname);
554	/* read basic solution from text file */
555
556	int glp_write_sol(glp_prob P, const char fname);
557	/* write basic solution to text file */
558
559	int glp_print_ranges(glp_prob *P, int len, const int list[],
560	int flags, const char *fname);
561	/* print sensitivity analysis report */
562
563	int glp_print_ipt(glp_prob P, const char fname);
564	/* write interior-point solution in printable format */
565
566	int glp_read_ipt(glp_prob P, const char fname);
567	/* read interior-point solution from text file */
568
569	int glp_write_ipt(glp_prob P, const char fname);
570	/* write interior-point solution to text file */
571
572	int glp_print_mip(glp_prob P, const char fname);
573	/* write MIP solution in printable format */
574
575	int glp_read_mip(glp_prob P, const char fname);
576	/* read MIP solution from text file */
577
578	int glp_write_mip(glp_prob P, const char fname);
579	/* write MIP solution to text file */
580
581	int glp_bf_exists(glp_prob *P);
582	/* check if the basis factorization exists */
583
584	int glp_factorize(glp_prob *P);
585	/* compute the basis factorization */
586
587	int glp_bf_updated(glp_prob *P);
588	/* check if the basis factorization has been updated */
589
590	void glp_get_bfcp(glp_prob P, glp_bfcp parm);
591	/* retrieve basis factorization control parameters */
592
593	void glp_set_bfcp(glp_prob P, const glp_bfcp parm);
594	/* change basis factorization control parameters */
595
596	int glp_get_bhead(glp_prob *P, int k);
597	/* retrieve the basis header information */
598
599	int glp_get_row_bind(glp_prob *P, int i);
600	/* retrieve row index in the basis header */
601
602	int glp_get_col_bind(glp_prob *P, int j);
603	/* retrieve column index in the basis header */
604
605	void glp_ftran(glp_prob *P, double x[]);
606	/* perform forward transformation (solve system Bx = b) /
607
608	void glp_btran(glp_prob *P, double x[]);
609	/* perform backward transformation (solve system B'x = b) /
610
611	int glp_warm_up(glp_prob *P);
612	/* "warm up" LP basis */
613
614	int glp_eval_tab_row(glp_prob *P, int k, int ind[], double val[]);
615	/* compute row of the simplex tableau */
616
617	int glp_eval_tab_col(glp_prob *P, int k, int ind[], double val[]);
618	/* compute column of the simplex tableau */
619
620	int glp_transform_row(glp_prob *P, int len, int ind[], double val[]);
621	/* transform explicitly specified row */
622
623	int glp_transform_col(glp_prob *P, int len, int ind[], double val[]);
624	/* transform explicitly specified column */
625
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 */
629
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 */
633
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 */
637
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 */
641
642	int glp_ios_reason(glp_tree *T);
643	/* determine reason for calling the callback routine */
644
645	glp_prob glp_ios_get_prob(glp_tree T);
646	/* access the problem object */
647
648	void glp_ios_tree_size(glp_tree T, int a_cnt, int *n_cnt,
649	int *t_cnt);
650	/* determine size of the branch-and-bound tree */
651
652	int glp_ios_curr_node(glp_tree *T);
653	/* determine current active subproblem */
654
655	int glp_ios_next_node(glp_tree *T, int p);
656	/* determine next active subproblem */
657
658	int glp_ios_prev_node(glp_tree *T, int p);
659	/* determine previous active subproblem */
660
661	int glp_ios_up_node(glp_tree *T, int p);
662	/* determine parent subproblem */
663
664	int glp_ios_node_level(glp_tree *T, int p);
665	/* determine subproblem level */
666
667	double glp_ios_node_bound(glp_tree *T, int p);
668	/* determine subproblem local bound */
669
670	int glp_ios_best_node(glp_tree *T);
671	/* find active subproblem with best local bound */
672
673	double glp_ios_mip_gap(glp_tree *T);
674	/* compute relative MIP gap */
675
676	void glp_ios_node_data(glp_tree T, int p);
677	/* access subproblem application-specific data */
678
679	void glp_ios_row_attr(glp_tree T, int i, glp_attr attr);
680	/* retrieve additional row attributes */
681
682	int glp_ios_pool_size(glp_tree *T);
683	/* determine current size of the cut pool */
684
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 */
689
690	void glp_ios_del_row(glp_tree *T, int i);
691	/* remove row (constraint) from the cut pool */
692
693	void glp_ios_clear_pool(glp_tree *T);
694	/* remove all rows (constraints) from the cut pool */
695
696	int glp_ios_can_branch(glp_tree *T, int j);
697	/* check if can branch upon specified variable */
698
699	void glp_ios_branch_upon(glp_tree *T, int j, int sel);
700	/* choose variable to branch upon */
701
702	void glp_ios_select_node(glp_tree *T, int p);
703	/* select subproblem to continue the search */
704
705	int glp_ios_heur_sol(glp_tree *T, const double x[]);
706	/* provide solution found by heuristic */
707
708	void glp_ios_terminate(glp_tree *T);
709	/* terminate the solution process */
710
711	void glp_init_mpscp(glp_mpscp *parm);
712	/* initialize MPS format control parameters */
713
714	int glp_read_mps(glp_prob P, int fmt, const glp_mpscp parm,
715	const char *fname);
716	/* read problem data in MPS format */
717
718	int glp_write_mps(glp_prob P, int fmt, const glp_mpscp parm,
719	const char *fname);
720	/* write problem data in MPS format */
721
722	void glp_init_cpxcp(glp_cpxcp *parm);
723	/* initialize CPLEX LP format control parameters */
724
725	int glp_read_lp(glp_prob P, const glp_cpxcp parm, const char *fname);
726	/* read problem data in CPLEX LP format */
727
728	int glp_write_lp(glp_prob P, const glp_cpxcp parm, const char *fname);
729	/* write problem data in CPLEX LP format */
730
731	int glp_read_prob(glp_prob P, int flags, const char fname);
732	/* read problem data in GLPK format */
733
734	int glp_write_prob(glp_prob P, int flags, const char fname);
735	/* write problem data in GLPK format */
736
737	glp_tran *glp_mpl_alloc_wksp(void);
738	/* allocate the MathProg translator workspace */
739
740	int glp_mpl_read_model(glp_tran tran, const char fname, int skip);
741	/* read and translate model section */
742
743	int glp_mpl_read_data(glp_tran tran, const char fname);
744	/* read and translate data section */
745
746	int glp_mpl_generate(glp_tran tran, const char fname);
747	/* generate the model */
748
749	void glp_mpl_build_prob(glp_tran tran, glp_prob prob);
750	/* build LP/MIP problem instance from the model */
751
752	int glp_mpl_postsolve(glp_tran tran, glp_prob prob, int sol);
753	/* postsolve the model */
754
755	void glp_mpl_free_wksp(glp_tran *tran);
756	/* free the MathProg translator workspace */
757
758	int glp_main(int argc, const char *argv[]);
759	/* stand-alone LP/MIP solver */
760
761	/**********************************************************************/
762
763	int glp_read_cnfsat(glp_prob P, const char fname);
764	/* read CNF-SAT problem data in DIMACS format */
765
766	int glp_check_cnfsat(glp_prob *P);
767	/* check for CNF-SAT problem instance */
768
769	int glp_write_cnfsat(glp_prob P, const char fname);
770	/* write CNF-SAT problem data in DIMACS format */
771
772	int glp_minisat1(glp_prob *P);
773	/* solve CNF-SAT problem with MiniSat solver */
774
775	int glp_intfeas1(glp_prob *P, int use_bound, int obj_bound);
776	/* solve integer feasibility problem */
777
778	/**********************************************************************/
779
780	#ifndef GLP_LONG_DEFINED
781	#define GLP_LONG_DEFINED
782	typedef struct { int lo, hi; } glp_long;
783	/* long integer data type */
784	#endif
785
786	int glp_init_env(void);
787	/* initialize GLPK environment */
788
789	const char *glp_version(void);
790	/* determine library version */
791
792	int glp_free_env(void);
793	/* free GLPK environment */
794
795	void glp_printf(const char *fmt, ...);
796	/* write formatted output to terminal */
797
798	void glp_vprintf(const char *fmt, va_list arg);
799	/* write formatted output to terminal */
800
801	int glp_term_out(int flag);
802	/* enable/disable terminal output */
803
804	void glp_term_hook(int (func)(void info, const char s), void info);
805	/* install hook to intercept terminal output */
806
807	int glp_open_tee(const char *fname);
808	/* start copying terminal output to text file */
809
810	int glp_close_tee(void);
811	/* stop copying terminal output to text file */
812
813	#ifndef GLP_ERROR_DEFINED
814	#define GLP_ERROR_DEFINED
815	typedef void (_glp_error)(const char fmt, ...);
816	#endif
817
818	#define glp_error glp_error_(__FILE__, __LINE__)
819	_glp_error glp_error_(const char *file, int line);
820	/* display error message and terminate execution */
821
822	#define glp_assert(expr) \
823	((void)((expr) \|\| (glp_assert_(#expr, __FILE__, __LINE__), 1)))
824	void glp_assert_(const char expr, const char file, int line);
825	/* check for logical condition */
826
827	void glp_error_hook(void (func)(void info), void *info);
828	/* install hook to intercept abnormal termination */
829
830	void *glp_malloc(int size);
831	/* allocate memory block */
832
833	void *glp_calloc(int n, int size);
834	/* allocate memory block */
835
836	void glp_free(void *ptr);
837	/* free memory block */
838
839	void glp_mem_limit(int limit);
840	/* set memory usage limit */
841
842	void glp_mem_usage(int count, int cpeak, glp_long *total,
843	glp_long *tpeak);
844	/* get memory usage information */
845
846	glp_long glp_time(void);
847	/* determine current universal time */
848
849	double glp_difftime(glp_long t1, glp_long t0);
850	/* compute difference between two time values */
851
852	/**********************************************************************/
853
854	#ifndef GLP_DATA_DEFINED
855	#define GLP_DATA_DEFINED
856	typedef struct { double _opaque_data[100]; } glp_data;
857	/* plain data file */
858	#endif
859
860	glp_data glp_sdf_open_file(const char fname);
861	/* open plain data file */
862
863	void glp_sdf_set_jump(glp_data data, void jump);
864	/* set up error handling */
865
866	void glp_sdf_error(glp_data data, const char fmt, ...);
867	/* print error message */
868
869	void glp_sdf_warning(glp_data data, const char fmt, ...);
870	/* print warning message */
871
872	int glp_sdf_read_int(glp_data *data);
873	/* read integer number */
874
875	double glp_sdf_read_num(glp_data *data);
876	/* read floating-point number */
877
878	const char glp_sdf_read_item(glp_data data);
879	/* read data item */
880
881	const char glp_sdf_read_text(glp_data data);
882	/* read text until end of line */
883
884	int glp_sdf_line(glp_data *data);
885	/* determine current line number */
886
887	void glp_sdf_close_file(glp_data *data);
888	/* close plain data file */
889
890	/**********************************************************************/
891
892	typedef struct _glp_graph glp_graph;
893	typedef struct _glp_vertex glp_vertex;
894	typedef struct _glp_arc glp_arc;
895
896	struct _glp_graph
897	{ /* graph descriptor */
898	void pool; / DMP pool; /
899	/* memory pool to store graph components */
900	char *name;
901	/* graph name (1 to 255 chars); NULL means no name is assigned
902	to the graph */
903	int nv_max;
904	/* length of the vertex list (enlarged automatically) */
905	int nv;
906	/* number of vertices in the graph, 0 <= nv <= nv_max */
907	int na;
908	/* number of arcs in the graph, na >= 0 */
909	glp_vertex *v; / glp_vertex v[1+nv_max]; /
910	/* v[i], 1 <= i <= nv, is a pointer to i-th vertex */
911	void index; / AVL index; /
912	/* vertex index to find vertices by their names; NULL means the
913	index does not exist */
914	int v_size;
915	/* size of data associated with each vertex (0 to 256 bytes) */
916	int a_size;
917	/* size of data associated with each arc (0 to 256 bytes) */
918	};
919
920	struct _glp_vertex
921	{ /* vertex descriptor */
922	int i;
923	/* vertex ordinal number, 1 <= i <= nv */
924	char *name;
925	/* vertex name (1 to 255 chars); NULL means no name is assigned
926	to the vertex */
927	void entry; / AVLNODE entry; /
928	/* pointer to corresponding entry in the vertex index; NULL means
929	that either the index does not exist or the vertex has no name
930	assigned */
931	void *data;
932	/* pointer to data associated with the vertex */
933	void *temp;
934	/* working pointer */
935	glp_arc *in;
936	/* pointer to the (unordered) list of incoming arcs */
937	glp_arc *out;
938	/* pointer to the (unordered) list of outgoing arcs */
939	};
940
941	struct _glp_arc
942	{ /* arc descriptor */
943	glp_vertex *tail;
944	/* pointer to the tail endpoint */
945	glp_vertex *head;
946	/* pointer to the head endpoint */
947	void *data;
948	/* pointer to data associated with the arc */
949	void *temp;
950	/* working pointer */
951	glp_arc *t_prev;
952	/* pointer to previous arc having the same tail endpoint */
953	glp_arc *t_next;
954	/* pointer to next arc having the same tail endpoint */
955	glp_arc *h_prev;
956	/* pointer to previous arc having the same head endpoint */
957	glp_arc *h_next;
958	/* pointer to next arc having the same head endpoint */
959	};
960
961	glp_graph *glp_create_graph(int v_size, int a_size);
962	/* create graph */
963
964	void glp_set_graph_name(glp_graph G, const char name);
965	/* assign (change) graph name */
966
967	int glp_add_vertices(glp_graph *G, int nadd);
968	/* add new vertices to graph */
969
970	void glp_set_vertex_name(glp_graph G, int i, const char name);
971	/* assign (change) vertex name */
972
973	glp_arc glp_add_arc(glp_graph G, int i, int j);
974	/* add new arc to graph */
975
976	void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
977	/* delete vertices from graph */
978
979	void glp_del_arc(glp_graph G, glp_arc a);
980	/* delete arc from graph */
981
982	void glp_erase_graph(glp_graph *G, int v_size, int a_size);
983	/* erase graph content */
984
985	void glp_delete_graph(glp_graph *G);
986	/* delete graph */
987
988	void glp_create_v_index(glp_graph *G);
989	/* create vertex name index */
990
991	int glp_find_vertex(glp_graph G, const char name);
992	/* find vertex by its name */
993
994	void glp_delete_v_index(glp_graph *G);
995	/* delete vertex name index */
996
997	int glp_read_graph(glp_graph G, const char fname);
998	/* read graph from plain text file */
999
1000	int glp_write_graph(glp_graph G, const char fname);
1001	/* write graph to plain text file */
1002
1003	void glp_mincost_lp(glp_prob P, glp_graph G, int names, int v_rhs,
1004	int a_low, int a_cap, int a_cost);
1005	/* convert minimum cost flow problem to LP */
1006
1007	int glp_mincost_okalg(glp_graph *G, int v_rhs, int a_low, int a_cap,
1008	int a_cost, double *sol, int a_x, int v_pi);
1009	/* find minimum-cost flow with out-of-kilter algorithm */
1010
1011	void glp_maxflow_lp(glp_prob P, glp_graph G, int names, int s,
1012	int t, int a_cap);
1013	/* convert maximum flow problem to LP */
1014
1015	int glp_maxflow_ffalg(glp_graph *G, int s, int t, int a_cap,
1016	double *sol, int a_x, int v_cut);
1017	/* find maximal flow with Ford-Fulkerson algorithm */
1018
1019	int glp_check_asnprob(glp_graph *G, int v_set);
1020	/* check correctness of assignment problem data */
1021
1022	/* assignment problem formulation: */
1023	#define GLP_ASN_MIN 1 /* perfect matching (minimization) */
1024	#define GLP_ASN_MAX 2 /* perfect matching (maximization) */
1025	#define GLP_ASN_MMP 3 /* maximum matching */
1026
1027	int glp_asnprob_lp(glp_prob P, int form, glp_graph G, int names,
1028	int v_set, int a_cost);
1029	/* convert assignment problem to LP */
1030
1031	int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
1032	double *sol, int a_x);
1033	/* solve assignment problem with out-of-kilter algorithm */
1034
1035	int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
1036	/* find bipartite matching of maximum cardinality */
1037
1038	double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
1039	/* solve critical path problem */
1040
1041	int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1042	int a_cost, const char *fname);
1043	/* read min-cost flow problem data in DIMACS format */
1044
1045	int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1046	int a_cost, const char *fname);
1047	/* write min-cost flow problem data in DIMACS format */
1048
1049	int glp_read_maxflow(glp_graph G, int s, int *t, int a_cap,
1050	const char *fname);
1051	/* read maximum flow problem data in DIMACS format */
1052
1053	int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
1054	const char *fname);
1055	/* write maximum flow problem data in DIMACS format */
1056
1057	int glp_read_asnprob(glp_graph *G, int v_set, int a_cost, const char
1058	*fname);
1059	/* read assignment problem data in DIMACS format */
1060
1061	int glp_write_asnprob(glp_graph *G, int v_set, int a_cost, const char
1062	*fname);
1063	/* write assignment problem data in DIMACS format */
1064
1065	int glp_read_ccdata(glp_graph G, int v_wgt, const char fname);
1066	/* read graph in DIMACS clique/coloring format */
1067
1068	int glp_write_ccdata(glp_graph G, int v_wgt, const char fname);
1069	/* write graph in DIMACS clique/coloring format */
1070
1071	int glp_netgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1072	const int parm[1+15]);
1073	/* Klingman's network problem generator */
1074
1075	int glp_gridgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1076	const int parm[1+14]);
1077	/* grid-like network problem generator */
1078
1079	int glp_rmfgen(glp_graph G, int s, int *t, int a_cap,
1080	const int parm[1+5]);
1081	/* Goldfarb's maximum flow problem generator */
1082
1083	int glp_weak_comp(glp_graph *G, int v_num);
1084	/* find all weakly connected components of graph */
1085
1086	int glp_strong_comp(glp_graph *G, int v_num);
1087	/* find all strongly connected components of graph */
1088
1089	int glp_top_sort(glp_graph *G, int v_num);
1090	/* topological sorting of acyclic digraph */
1091
1092	int glp_wclique_exact(glp_graph G, int v_wgt, double sol, int v_set);
1093	/* find maximum weight clique with exact algorithm */
1094
1095	/***********************************************************************
1096	* NOTE: All symbols defined below are obsolete and kept here only for
1097	* backward compatibility.
1098	***********************************************************************/
1099
1100	#define LPX glp_prob
1101
1102	/* problem class: */
1103	#define LPX_LP 100 /* linear programming (LP) */
1104	#define LPX_MIP 101 /* mixed integer programming (MIP) */
1105
1106	/* type of auxiliary/structural variable: */
1107	#define LPX_FR 110 /* free variable */
1108	#define LPX_LO 111 /* variable with lower bound */
1109	#define LPX_UP 112 /* variable with upper bound */
1110	#define LPX_DB 113 /* double-bounded variable */
1111	#define LPX_FX 114 /* fixed variable */
1112
1113	/* optimization direction flag: */
1114	#define LPX_MIN 120 /* minimization */
1115	#define LPX_MAX 121 /* maximization */
1116
1117	/* status of primal basic solution: */
1118	#define LPX_P_UNDEF 132 /* primal solution is undefined */
1119	#define LPX_P_FEAS 133 /* solution is primal feasible */
1120	#define LPX_P_INFEAS 134 /* solution is primal infeasible */
1121	#define LPX_P_NOFEAS 135 /* no primal feasible solution exists */
1122
1123	/* status of dual basic solution: */
1124	#define LPX_D_UNDEF 136 /* dual solution is undefined */
1125	#define LPX_D_FEAS 137 /* solution is dual feasible */
1126	#define LPX_D_INFEAS 138 /* solution is dual infeasible */
1127	#define LPX_D_NOFEAS 139 /* no dual feasible solution exists */
1128
1129	/* status of auxiliary/structural variable: */
1130	#define LPX_BS 140 /* basic variable */
1131	#define LPX_NL 141 /* non-basic variable on lower bound */
1132	#define LPX_NU 142 /* non-basic variable on upper bound */
1133	#define LPX_NF 143 /* non-basic free variable */
1134	#define LPX_NS 144 /* non-basic fixed variable */
1135
1136	/* status of interior-point solution: */
1137	#define LPX_T_UNDEF 150 /* interior solution is undefined */
1138	#define LPX_T_OPT 151 /* interior solution is optimal */
1139
1140	/* kind of structural variable: */
1141	#define LPX_CV 160 /* continuous variable */
1142	#define LPX_IV 161 /* integer variable */
1143
1144	/* status of integer solution: */
1145	#define LPX_I_UNDEF 170 /* integer solution is undefined */
1146	#define LPX_I_OPT 171 /* integer solution is optimal */
1147	#define LPX_I_FEAS 172 /* integer solution is feasible */
1148	#define LPX_I_NOFEAS 173 /* no integer solution exists */
1149
1150	/* status codes reported by the routine lpx_get_status: */
1151	#define LPX_OPT 180 /* optimal */
1152	#define LPX_FEAS 181 /* feasible */
1153	#define LPX_INFEAS 182 /* infeasible */
1154	#define LPX_NOFEAS 183 /* no feasible */
1155	#define LPX_UNBND 184 /* unbounded */
1156	#define LPX_UNDEF 185 /* undefined */
1157
1158	/* exit codes returned by solver routines: */
1159	#define LPX_E_OK 200 /* success */
1160	#define LPX_E_EMPTY 201 /* empty problem */
1161	#define LPX_E_BADB 202 /* invalid initial basis */
1162	#define LPX_E_INFEAS 203 /* infeasible initial solution */
1163	#define LPX_E_FAULT 204 /* unable to start the search */
1164	#define LPX_E_OBJLL 205 /* objective lower limit reached */
1165	#define LPX_E_OBJUL 206 /* objective upper limit reached */
1166	#define LPX_E_ITLIM 207 /* iterations limit exhausted */
1167	#define LPX_E_TMLIM 208 /* time limit exhausted */
1168	#define LPX_E_NOFEAS 209 /* no feasible solution */
1169	#define LPX_E_INSTAB 210 /* numerical instability */
1170	#define LPX_E_SING 211 /* problems with basis matrix */
1171	#define LPX_E_NOCONV 212 /* no convergence (interior) */
1172	#define LPX_E_NOPFS 213 /* no primal feas. sol. (LP presolver) */
1173	#define LPX_E_NODFS 214 /* no dual feas. sol. (LP presolver) */
1174	#define LPX_E_MIPGAP 215 /* relative mip gap tolerance reached */
1175
1176	/* control parameter identifiers: */
1177	#define LPX_K_MSGLEV 300 /* lp->msg_lev */
1178	#define LPX_K_SCALE 301 /* lp->scale */
1179	#define LPX_K_DUAL 302 /* lp->dual */
1180	#define LPX_K_PRICE 303 /* lp->price */
1181	#define LPX_K_RELAX 304 /* lp->relax */
1182	#define LPX_K_TOLBND 305 /* lp->tol_bnd */
1183	#define LPX_K_TOLDJ 306 /* lp->tol_dj */
1184	#define LPX_K_TOLPIV 307 /* lp->tol_piv */
1185	#define LPX_K_ROUND 308 /* lp->round */
1186	#define LPX_K_OBJLL 309 /* lp->obj_ll */
1187	#define LPX_K_OBJUL 310 /* lp->obj_ul */
1188	#define LPX_K_ITLIM 311 /* lp->it_lim */
1189	#define LPX_K_ITCNT 312 /* lp->it_cnt */
1190	#define LPX_K_TMLIM 313 /* lp->tm_lim */
1191	#define LPX_K_OUTFRQ 314 /* lp->out_frq */
1192	#define LPX_K_OUTDLY 315 /* lp->out_dly */
1193	#define LPX_K_BRANCH 316 /* lp->branch */
1194	#define LPX_K_BTRACK 317 /* lp->btrack */
1195	#define LPX_K_TOLINT 318 /* lp->tol_int */
1196	#define LPX_K_TOLOBJ 319 /* lp->tol_obj */
1197	#define LPX_K_MPSINFO 320 /* lp->mps_info */
1198	#define LPX_K_MPSOBJ 321 /* lp->mps_obj */
1199	#define LPX_K_MPSORIG 322 /* lp->mps_orig */
1200	#define LPX_K_MPSWIDE 323 /* lp->mps_wide */
1201	#define LPX_K_MPSFREE 324 /* lp->mps_free */
1202	#define LPX_K_MPSSKIP 325 /* lp->mps_skip */
1203	#define LPX_K_LPTORIG 326 /* lp->lpt_orig */
1204	#define LPX_K_PRESOL 327 /* lp->presol */
1205	#define LPX_K_BINARIZE 328 /* lp->binarize */
1206	#define LPX_K_USECUTS 329 /* lp->use_cuts */
1207	#define LPX_K_BFTYPE 330 /* lp->bfcp->type */
1208	#define LPX_K_MIPGAP 331 /* lp->mip_gap */
1209
1210	#define LPX_C_COVER 0x01 /* mixed cover cuts */
1211	#define LPX_C_CLIQUE 0x02 /* clique cuts */
1212	#define LPX_C_GOMORY 0x04 /* Gomory's mixed integer cuts */
1213	#define LPX_C_MIR 0x08 /* mixed integer rounding cuts */
1214	#define LPX_C_ALL 0xFF /* all cuts */
1215
1216	typedef struct
1217	{ /* this structure contains results reported by the routines which
1218	checks Karush-Kuhn-Tucker conditions (for details see comments
1219	to those routines) */
1220	/--------------------------------------------------------------/
1221	/* xR - A * xS = 0 (KKT.PE) */
1222	double pe_ae_max;
1223	/* largest absolute error */
1224	int pe_ae_row;
1225	/* number of row with largest absolute error */
1226	double pe_re_max;
1227	/* largest relative error */
1228	int pe_re_row;
1229	/* number of row with largest relative error */
1230	int pe_quality;
1231	/* quality of primal solution:
1232	'H' - high
1233	'M' - medium
1234	'L' - low
1235	'?' - primal solution is wrong */
1236	/--------------------------------------------------------------/
1237	/* l[k] <= x[k] <= u[k] (KKT.PB) */
1238	double pb_ae_max;
1239	/* largest absolute error */
1240	int pb_ae_ind;
1241	/* number of variable with largest absolute error */
1242	double pb_re_max;
1243	/* largest relative error */
1244	int pb_re_ind;
1245	/* number of variable with largest relative error */
1246	int pb_quality;
1247	/* quality of primal feasibility:
1248	'H' - high
1249	'M' - medium
1250	'L' - low
1251	'?' - primal solution is infeasible */
1252	/--------------------------------------------------------------/
1253	/* A' * (dR - cR) + (dS - cS) = 0 (KKT.DE) */
1254	double de_ae_max;
1255	/* largest absolute error */
1256	int de_ae_col;
1257	/* number of column with largest absolute error */
1258	double de_re_max;
1259	/* largest relative error */
1260	int de_re_col;
1261	/* number of column with largest relative error */
1262	int de_quality;
1263	/* quality of dual solution:
1264	'H' - high
1265	'M' - medium
1266	'L' - low
1267	'?' - dual solution is wrong */
1268	/--------------------------------------------------------------/
1269	/* d[k] >= 0 or d[k] <= 0 (KKT.DB) */
1270	double db_ae_max;
1271	/* largest absolute error */
1272	int db_ae_ind;
1273	/* number of variable with largest absolute error */
1274	double db_re_max;
1275	/* largest relative error */
1276	int db_re_ind;
1277	/* number of variable with largest relative error */
1278	int db_quality;
1279	/* quality of dual feasibility:
1280	'H' - high
1281	'M' - medium
1282	'L' - low
1283	'?' - dual solution is infeasible */
1284	/--------------------------------------------------------------/
1285	/* (x[k] - bound of x[k]) * d[k] = 0 (KKT.CS) */
1286	double cs_ae_max;
1287	/* largest absolute error */
1288	int cs_ae_ind;
1289	/* number of variable with largest absolute error */
1290	double cs_re_max;
1291	/* largest relative error */
1292	int cs_re_ind;
1293	/* number of variable with largest relative error */
1294	int cs_quality;
1295	/* quality of complementary slackness:
1296	'H' - high
1297	'M' - medium
1298	'L' - low
1299	'?' - primal and dual solutions are not complementary */
1300	} LPXKKT;
1301
1302	#define lpx_create_prob _glp_lpx_create_prob
1303	LPX *lpx_create_prob(void);
1304	/* create problem object */
1305
1306	#define lpx_set_prob_name _glp_lpx_set_prob_name
1307	void lpx_set_prob_name(LPX lp, const char name);
1308	/* assign (change) problem name */
1309
1310	#define lpx_set_obj_name _glp_lpx_set_obj_name
1311	void lpx_set_obj_name(LPX lp, const char name);
1312	/* assign (change) objective function name */
1313
1314	#define lpx_set_obj_dir _glp_lpx_set_obj_dir
1315	void lpx_set_obj_dir(LPX *lp, int dir);
1316	/* set (change) optimization direction flag */
1317
1318	#define lpx_add_rows _glp_lpx_add_rows
1319	int lpx_add_rows(LPX *lp, int nrs);
1320	/* add new rows to problem object */
1321
1322	#define lpx_add_cols _glp_lpx_add_cols
1323	int lpx_add_cols(LPX *lp, int ncs);
1324	/* add new columns to problem object */
1325
1326	#define lpx_set_row_name _glp_lpx_set_row_name
1327	void lpx_set_row_name(LPX lp, int i, const char name);
1328	/* assign (change) row name */
1329
1330	#define lpx_set_col_name _glp_lpx_set_col_name
1331	void lpx_set_col_name(LPX lp, int j, const char name);
1332	/* assign (change) column name */
1333
1334	#define lpx_set_row_bnds _glp_lpx_set_row_bnds
1335	void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub);
1336	/* set (change) row bounds */
1337
1338	#define lpx_set_col_bnds _glp_lpx_set_col_bnds
1339	void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub);
1340	/* set (change) column bounds */
1341
1342	#define lpx_set_obj_coef _glp_lpx_set_obj_coef
1343	void lpx_set_obj_coef(glp_prob *lp, int j, double coef);
1344	/* set (change) obj. coefficient or constant term */
1345
1346	#define lpx_set_mat_row _glp_lpx_set_mat_row
1347	void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
1348	const double val[]);
1349	/* set (replace) row of the constraint matrix */
1350
1351	#define lpx_set_mat_col _glp_lpx_set_mat_col
1352	void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
1353	const double val[]);
1354	/* set (replace) column of the constraint matrix */
1355
1356	#define lpx_load_matrix _glp_lpx_load_matrix
1357	void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
1358	const double ar[]);
1359	/* load (replace) the whole constraint matrix */
1360
1361	#define lpx_del_rows _glp_lpx_del_rows
1362	void lpx_del_rows(LPX *lp, int nrs, const int num[]);
1363	/* delete specified rows from problem object */
1364
1365	#define lpx_del_cols _glp_lpx_del_cols
1366	void lpx_del_cols(LPX *lp, int ncs, const int num[]);
1367	/* delete specified columns from problem object */
1368
1369	#define lpx_delete_prob _glp_lpx_delete_prob
1370	void lpx_delete_prob(LPX *lp);
1371	/* delete problem object */
1372
1373	#define lpx_get_prob_name _glp_lpx_get_prob_name
1374	const char lpx_get_prob_name(LPX lp);
1375	/* retrieve problem name */
1376
1377	#define lpx_get_obj_name _glp_lpx_get_obj_name
1378	const char lpx_get_obj_name(LPX lp);
1379	/* retrieve objective function name */
1380
1381	#define lpx_get_obj_dir _glp_lpx_get_obj_dir
1382	int lpx_get_obj_dir(LPX *lp);
1383	/* retrieve optimization direction flag */
1384
1385	#define lpx_get_num_rows _glp_lpx_get_num_rows
1386	int lpx_get_num_rows(LPX *lp);
1387	/* retrieve number of rows */
1388
1389	#define lpx_get_num_cols _glp_lpx_get_num_cols
1390	int lpx_get_num_cols(LPX *lp);
1391	/* retrieve number of columns */
1392
1393	#define lpx_get_row_name _glp_lpx_get_row_name
1394	const char lpx_get_row_name(LPX lp, int i);
1395	/* retrieve row name */
1396
1397	#define lpx_get_col_name _glp_lpx_get_col_name
1398	const char lpx_get_col_name(LPX lp, int j);
1399	/* retrieve column name */
1400
1401	#define lpx_get_row_type _glp_lpx_get_row_type
1402	int lpx_get_row_type(LPX *lp, int i);
1403	/* retrieve row type */
1404
1405	#define lpx_get_row_lb _glp_lpx_get_row_lb
1406	double lpx_get_row_lb(LPX *lp, int i);
1407	/* retrieve row lower bound */
1408
1409	#define lpx_get_row_ub _glp_lpx_get_row_ub
1410	double lpx_get_row_ub(LPX *lp, int i);
1411	/* retrieve row upper bound */
1412
1413	#define lpx_get_row_bnds _glp_lpx_get_row_bnds
1414	void lpx_get_row_bnds(LPX lp, int i, int typx, double *lb,
1415	double *ub);
1416	/* retrieve row bounds */
1417
1418	#define lpx_get_col_type _glp_lpx_get_col_type
1419	int lpx_get_col_type(LPX *lp, int j);
1420	/* retrieve column type */
1421
1422	#define lpx_get_col_lb _glp_lpx_get_col_lb
1423	double lpx_get_col_lb(LPX *lp, int j);
1424	/* retrieve column lower bound */
1425
1426	#define lpx_get_col_ub _glp_lpx_get_col_ub
1427	double lpx_get_col_ub(LPX *lp, int j);
1428	/* retrieve column upper bound */
1429
1430	#define lpx_get_col_bnds _glp_lpx_get_col_bnds
1431	void lpx_get_col_bnds(LPX lp, int j, int typx, double *lb,
1432	double *ub);
1433	/* retrieve column bounds */
1434
1435	#define lpx_get_obj_coef _glp_lpx_get_obj_coef
1436	double lpx_get_obj_coef(LPX *lp, int j);
1437	/* retrieve obj. coefficient or constant term */
1438
1439	#define lpx_get_num_nz _glp_lpx_get_num_nz
1440	int lpx_get_num_nz(LPX *lp);
1441	/* retrieve number of constraint coefficients */
1442
1443	#define lpx_get_mat_row _glp_lpx_get_mat_row
1444	int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[]);
1445	/* retrieve row of the constraint matrix */
1446
1447	#define lpx_get_mat_col _glp_lpx_get_mat_col
1448	int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[]);
1449	/* retrieve column of the constraint matrix */
1450
1451	#define lpx_create_index _glp_lpx_create_index
1452	void lpx_create_index(LPX *lp);
1453	/* create the name index */
1454
1455	#define lpx_find_row _glp_lpx_find_row
1456	int lpx_find_row(LPX lp, const char name);
1457	/* find row by its name */
1458
1459	#define lpx_find_col _glp_lpx_find_col
1460	int lpx_find_col(LPX lp, const char name);
1461	/* find column by its name */
1462
1463	#define lpx_delete_index _glp_lpx_delete_index
1464	void lpx_delete_index(LPX *lp);
1465	/* delete the name index */
1466
1467	#define lpx_scale_prob _glp_lpx_scale_prob
1468	void lpx_scale_prob(LPX *lp);
1469	/* scale problem data */
1470
1471	#define lpx_unscale_prob _glp_lpx_unscale_prob
1472	void lpx_unscale_prob(LPX *lp);
1473	/* unscale problem data */
1474
1475	#define lpx_set_row_stat _glp_lpx_set_row_stat
1476	void lpx_set_row_stat(LPX *lp, int i, int stat);
1477	/* set (change) row status */
1478
1479	#define lpx_set_col_stat _glp_lpx_set_col_stat
1480	void lpx_set_col_stat(LPX *lp, int j, int stat);
1481	/* set (change) column status */
1482
1483	#define lpx_std_basis _glp_lpx_std_basis
1484	void lpx_std_basis(LPX *lp);
1485	/* construct standard initial LP basis */
1486
1487	#define lpx_adv_basis _glp_lpx_adv_basis
1488	void lpx_adv_basis(LPX *lp);
1489	/* construct advanced initial LP basis */
1490
1491	#define lpx_cpx_basis _glp_lpx_cpx_basis
1492	void lpx_cpx_basis(LPX *lp);
1493	/* construct Bixby's initial LP basis */
1494
1495	#define lpx_simplex _glp_lpx_simplex
1496	int lpx_simplex(LPX *lp);
1497	/* easy-to-use driver to the simplex method */
1498
1499	#define lpx_exact _glp_lpx_exact
1500	int lpx_exact(LPX *lp);
1501	/* easy-to-use driver to the exact simplex method */
1502
1503	#define lpx_get_status _glp_lpx_get_status
1504	int lpx_get_status(LPX *lp);
1505	/* retrieve generic status of basic solution */
1506
1507	#define lpx_get_prim_stat _glp_lpx_get_prim_stat
1508	int lpx_get_prim_stat(LPX *lp);
1509	/* retrieve primal status of basic solution */
1510
1511	#define lpx_get_dual_stat _glp_lpx_get_dual_stat
1512	int lpx_get_dual_stat(LPX *lp);
1513	/* retrieve dual status of basic solution */
1514
1515	#define lpx_get_obj_val _glp_lpx_get_obj_val
1516	double lpx_get_obj_val(LPX *lp);
1517	/* retrieve objective value (basic solution) */
1518
1519	#define lpx_get_row_stat _glp_lpx_get_row_stat
1520	int lpx_get_row_stat(LPX *lp, int i);
1521	/* retrieve row status (basic solution) */
1522
1523	#define lpx_get_row_prim _glp_lpx_get_row_prim
1524	double lpx_get_row_prim(LPX *lp, int i);
1525	/* retrieve row primal value (basic solution) */
1526
1527	#define lpx_get_row_dual _glp_lpx_get_row_dual
1528	double lpx_get_row_dual(LPX *lp, int i);
1529	/* retrieve row dual value (basic solution) */
1530
1531	#define lpx_get_row_info _glp_lpx_get_row_info
1532	void lpx_get_row_info(LPX lp, int i, int tagx, double *vx,
1533	double *dx);
1534	/* obtain row solution information */
1535
1536	#define lpx_get_col_stat _glp_lpx_get_col_stat
1537	int lpx_get_col_stat(LPX *lp, int j);
1538	/* retrieve column status (basic solution) */
1539
1540	#define lpx_get_col_prim _glp_lpx_get_col_prim
1541	double lpx_get_col_prim(LPX *lp, int j);
1542	/* retrieve column primal value (basic solution) */
1543
1544	#define lpx_get_col_dual _glp_lpx_get_col_dual
1545	double lpx_get_col_dual(glp_prob *lp, int j);
1546	/* retrieve column dual value (basic solution) */
1547
1548	#define lpx_get_col_info _glp_lpx_get_col_info
1549	void lpx_get_col_info(LPX lp, int j, int tagx, double *vx,
1550	double *dx);
1551	/* obtain column solution information (obsolete) */
1552
1553	#define lpx_get_ray_info _glp_lpx_get_ray_info
1554	int lpx_get_ray_info(LPX *lp);
1555	/* determine what causes primal unboundness */
1556
1557	#define lpx_check_kkt _glp_lpx_check_kkt
1558	void lpx_check_kkt(LPX lp, int scaled, LPXKKT kkt);
1559	/* check Karush-Kuhn-Tucker conditions */
1560
1561	#define lpx_warm_up _glp_lpx_warm_up
1562	int lpx_warm_up(LPX *lp);
1563	/* "warm up" LP basis */
1564
1565	#define lpx_eval_tab_row _glp_lpx_eval_tab_row
1566	int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[]);
1567	/* compute row of the simplex table */
1568
1569	#define lpx_eval_tab_col _glp_lpx_eval_tab_col
1570	int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[]);
1571	/* compute column of the simplex table */
1572
1573	#define lpx_transform_row _glp_lpx_transform_row
1574	int lpx_transform_row(LPX *lp, int len, int ind[], double val[]);
1575	/* transform explicitly specified row */
1576
1577	#define lpx_transform_col _glp_lpx_transform_col
1578	int lpx_transform_col(LPX *lp, int len, int ind[], double val[]);
1579	/* transform explicitly specified column */
1580
1581	#define lpx_prim_ratio_test _glp_lpx_prim_ratio_test
1582	int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
1583	const double val[], int how, double tol);
1584	/* perform primal ratio test */
1585
1586	#define lpx_dual_ratio_test _glp_lpx_dual_ratio_test
1587	int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
1588	const double val[], int how, double tol);
1589	/* perform dual ratio test */
1590
1591	#define lpx_interior _glp_lpx_interior
1592	int lpx_interior(LPX *lp);
1593	/* easy-to-use driver to the interior point method */
1594
1595	#define lpx_ipt_status _glp_lpx_ipt_status
1596	int lpx_ipt_status(LPX *lp);
1597	/* retrieve status of interior-point solution */
1598
1599	#define lpx_ipt_obj_val _glp_lpx_ipt_obj_val
1600	double lpx_ipt_obj_val(LPX *lp);
1601	/* retrieve objective value (interior point) */
1602
1603	#define lpx_ipt_row_prim _glp_lpx_ipt_row_prim
1604	double lpx_ipt_row_prim(LPX *lp, int i);
1605	/* retrieve row primal value (interior point) */
1606
1607	#define lpx_ipt_row_dual _glp_lpx_ipt_row_dual
1608	double lpx_ipt_row_dual(LPX *lp, int i);
1609	/* retrieve row dual value (interior point) */
1610
1611	#define lpx_ipt_col_prim _glp_lpx_ipt_col_prim
1612	double lpx_ipt_col_prim(LPX *lp, int j);
1613	/* retrieve column primal value (interior point) */
1614
1615	#define lpx_ipt_col_dual _glp_lpx_ipt_col_dual
1616	double lpx_ipt_col_dual(LPX *lp, int j);
1617	/* retrieve column dual value (interior point) */
1618
1619	#define lpx_set_class _glp_lpx_set_class
1620	void lpx_set_class(LPX *lp, int klass);
1621	/* set problem class */
1622
1623	#define lpx_get_class _glp_lpx_get_class
1624	int lpx_get_class(LPX *lp);
1625	/* determine problem klass */
1626
1627	#define lpx_set_col_kind _glp_lpx_set_col_kind
1628	void lpx_set_col_kind(LPX *lp, int j, int kind);
1629	/* set (change) column kind */
1630
1631	#define lpx_get_col_kind _glp_lpx_get_col_kind
1632	int lpx_get_col_kind(LPX *lp, int j);
1633	/* retrieve column kind */
1634
1635	#define lpx_get_num_int _glp_lpx_get_num_int
1636	int lpx_get_num_int(LPX *lp);
1637	/* retrieve number of integer columns */
1638
1639	#define lpx_get_num_bin _glp_lpx_get_num_bin
1640	int lpx_get_num_bin(LPX *lp);
1641	/* retrieve number of binary columns */
1642
1643	#define lpx_integer _glp_lpx_integer
1644	int lpx_integer(LPX *lp);
1645	/* easy-to-use driver to the branch-and-bound method */
1646
1647	#define lpx_intopt _glp_lpx_intopt
1648	int lpx_intopt(LPX *lp);
1649	/* easy-to-use driver to the branch-and-bound method */
1650
1651	#define lpx_mip_status _glp_lpx_mip_status
1652	int lpx_mip_status(LPX *lp);
1653	/* retrieve status of MIP solution */
1654
1655	#define lpx_mip_obj_val _glp_lpx_mip_obj_val
1656	double lpx_mip_obj_val(LPX *lp);
1657	/* retrieve objective value (MIP solution) */
1658
1659	#define lpx_mip_row_val _glp_lpx_mip_row_val
1660	double lpx_mip_row_val(LPX *lp, int i);
1661	/* retrieve row value (MIP solution) */
1662
1663	#define lpx_mip_col_val _glp_lpx_mip_col_val
1664	double lpx_mip_col_val(LPX *lp, int j);
1665	/* retrieve column value (MIP solution) */
1666
1667	#define lpx_check_int _glp_lpx_check_int
1668	void lpx_check_int(LPX lp, LPXKKT kkt);
1669	/* check integer feasibility conditions */
1670
1671	#define lpx_reset_parms _glp_lpx_reset_parms
1672	void lpx_reset_parms(LPX *lp);
1673	/* reset control parameters to default values */
1674
1675	#define lpx_set_int_parm _glp_lpx_set_int_parm
1676	void lpx_set_int_parm(LPX *lp, int parm, int val);
1677	/* set (change) integer control parameter */
1678
1679	#define lpx_get_int_parm _glp_lpx_get_int_parm
1680	int lpx_get_int_parm(LPX *lp, int parm);
1681	/* query integer control parameter */
1682
1683	#define lpx_set_real_parm _glp_lpx_set_real_parm
1684	void lpx_set_real_parm(LPX *lp, int parm, double val);
1685	/* set (change) real control parameter */
1686
1687	#define lpx_get_real_parm _glp_lpx_get_real_parm
1688	double lpx_get_real_parm(LPX *lp, int parm);
1689	/* query real control parameter */
1690
1691	#define lpx_read_mps _glp_lpx_read_mps
1692	LPX lpx_read_mps(const char fname);
1693	/* read problem data in fixed MPS format */
1694
1695	#define lpx_write_mps _glp_lpx_write_mps
1696	int lpx_write_mps(LPX lp, const char fname);
1697	/* write problem data in fixed MPS format */
1698
1699	#define lpx_read_bas _glp_lpx_read_bas
1700	int lpx_read_bas(LPX lp, const char fname);
1701	/* read LP basis in fixed MPS format */
1702
1703	#define lpx_write_bas _glp_lpx_write_bas
1704	int lpx_write_bas(LPX lp, const char fname);
1705	/* write LP basis in fixed MPS format */
1706
1707	#define lpx_read_freemps _glp_lpx_read_freemps
1708	LPX lpx_read_freemps(const char fname);
1709	/* read problem data in free MPS format */
1710
1711	#define lpx_write_freemps _glp_lpx_write_freemps
1712	int lpx_write_freemps(LPX lp, const char fname);
1713	/* write problem data in free MPS format */
1714
1715	#define lpx_read_cpxlp _glp_lpx_read_cpxlp
1716	LPX lpx_read_cpxlp(const char fname);
1717	/* read problem data in CPLEX LP format */
1718
1719	#define lpx_write_cpxlp _glp_lpx_write_cpxlp
1720	int lpx_write_cpxlp(LPX lp, const char fname);
1721	/* write problem data in CPLEX LP format */
1722
1723	#define lpx_read_model _glp_lpx_read_model
1724	LPX lpx_read_model(const char model, const char *data,
1725	const char *output);
1726	/* read LP/MIP model written in GNU MathProg language */
1727
1728	#define lpx_print_prob _glp_lpx_print_prob
1729	int lpx_print_prob(LPX lp, const char fname);
1730	/* write problem data in plain text format */
1731
1732	#define lpx_print_sol _glp_lpx_print_sol
1733	int lpx_print_sol(LPX lp, const char fname);
1734	/* write LP problem solution in printable format */
1735
1736	#define lpx_print_sens_bnds _glp_lpx_print_sens_bnds
1737	int lpx_print_sens_bnds(LPX lp, const char fname);
1738	/* write bounds sensitivity information */
1739
1740	#define lpx_print_ips _glp_lpx_print_ips
1741	int lpx_print_ips(LPX lp, const char fname);
1742	/* write interior point solution in printable format */
1743
1744	#define lpx_print_mip _glp_lpx_print_mip
1745	int lpx_print_mip(LPX lp, const char fname);
1746	/* write MIP problem solution in printable format */
1747
1748	#define lpx_is_b_avail _glp_lpx_is_b_avail
1749	int lpx_is_b_avail(LPX *lp);
1750	/* check if LP basis is available */
1751
1752	#define lpx_write_pb _glp_lpx_write_pb
1753	int lpx_write_pb(LPX lp, const char fname, int normalized,
1754	int binarize);
1755	/* write problem data in (normalized) OPB format */
1756
1757	#define lpx_main _glp_lpx_main
1758	int lpx_main(int argc, const char *argv[]);
1759	/* stand-alone LP/MIP solver */
1760
1761	#ifdef __cplusplus
1762	}
1763	#endif
1764
1765	#endif
1766
1767	/* eof */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: lemon-project-template-glpk/deps/glpk/src/glpk.h @ 9:33de93886c88

Download in other formats: