COIN-OR::LEMON - Graph Library

source: lemon-project-template-glpk/deps/glpk/src/glpk.h @ 10:5545663ca997

subpack-glpk
Last change on this file since 10:5545663ca997 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
32extern "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
41typedef 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
88typedef 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
108typedef 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
139typedef 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
152typedef struct { double _opaque_tree[100]; } glp_tree;
153/* branch-and-bound tree */
154#endif
155
156typedef 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
197typedef 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
266typedef 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
278typedef 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
286typedef struct { double _opaque_tran[100]; } glp_tran;
287/* MathProg translator workspace */
288#endif
289
290glp_prob *glp_create_prob(void);
291/* create problem object */
292
293void glp_set_prob_name(glp_prob *P, const char *name);
294/* assign (change) problem name */
295
296void glp_set_obj_name(glp_prob *P, const char *name);
297/* assign (change) objective function name */
298
299void glp_set_obj_dir(glp_prob *P, int dir);
300/* set (change) optimization direction flag */
301
302int glp_add_rows(glp_prob *P, int nrs);
303/* add new rows to problem object */
304
305int glp_add_cols(glp_prob *P, int ncs);
306/* add new columns to problem object */
307
308void glp_set_row_name(glp_prob *P, int i, const char *name);
309/* assign (change) row name */
310
311void glp_set_col_name(glp_prob *P, int j, const char *name);
312/* assign (change) column name */
313
314void glp_set_row_bnds(glp_prob *P, int i, int type, double lb,
315      double ub);
316/* set (change) row bounds */
317
318void glp_set_col_bnds(glp_prob *P, int j, int type, double lb,
319      double ub);
320/* set (change) column bounds */
321
322void glp_set_obj_coef(glp_prob *P, int j, double coef);
323/* set (change) obj. coefficient or constant term */
324
325void 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
329void 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
333void 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
337int glp_check_dup(int m, int n, int ne, const int ia[], const int ja[]);
338/* check for duplicate elements in sparse matrix */
339
340void glp_sort_matrix(glp_prob *P);
341/* sort elements of the constraint matrix */
342
343void glp_del_rows(glp_prob *P, int nrs, const int num[]);
344/* delete specified rows from problem object */
345
346void glp_del_cols(glp_prob *P, int ncs, const int num[]);
347/* delete specified columns from problem object */
348
349void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names);
350/* copy problem object content */
351
352void glp_erase_prob(glp_prob *P);
353/* erase problem object content */
354
355void glp_delete_prob(glp_prob *P);
356/* delete problem object */
357
358const char *glp_get_prob_name(glp_prob *P);
359/* retrieve problem name */
360
361const char *glp_get_obj_name(glp_prob *P);
362/* retrieve objective function name */
363
364int glp_get_obj_dir(glp_prob *P);
365/* retrieve optimization direction flag */
366
367int glp_get_num_rows(glp_prob *P);
368/* retrieve number of rows */
369
370int glp_get_num_cols(glp_prob *P);
371/* retrieve number of columns */
372
373const char *glp_get_row_name(glp_prob *P, int i);
374/* retrieve row name */
375
376const char *glp_get_col_name(glp_prob *P, int j);
377/* retrieve column name */
378
379int glp_get_row_type(glp_prob *P, int i);
380/* retrieve row type */
381
382double glp_get_row_lb(glp_prob *P, int i);
383/* retrieve row lower bound */
384
385double glp_get_row_ub(glp_prob *P, int i);
386/* retrieve row upper bound */
387
388int glp_get_col_type(glp_prob *P, int j);
389/* retrieve column type */
390
391double glp_get_col_lb(glp_prob *P, int j);
392/* retrieve column lower bound */
393
394double glp_get_col_ub(glp_prob *P, int j);
395/* retrieve column upper bound */
396
397double glp_get_obj_coef(glp_prob *P, int j);
398/* retrieve obj. coefficient or constant term */
399
400int glp_get_num_nz(glp_prob *P);
401/* retrieve number of constraint coefficients */
402
403int glp_get_mat_row(glp_prob *P, int i, int ind[], double val[]);
404/* retrieve row of the constraint matrix */
405
406int glp_get_mat_col(glp_prob *P, int j, int ind[], double val[]);
407/* retrieve column of the constraint matrix */
408
409void glp_create_index(glp_prob *P);
410/* create the name index */
411
412int glp_find_row(glp_prob *P, const char *name);
413/* find row by its name */
414
415int glp_find_col(glp_prob *P, const char *name);
416/* find column by its name */
417
418void glp_delete_index(glp_prob *P);
419/* delete the name index */
420
421void glp_set_rii(glp_prob *P, int i, double rii);
422/* set (change) row scale factor */
423
424void glp_set_sjj(glp_prob *P, int j, double sjj);
425/* set (change) column scale factor */
426
427double glp_get_rii(glp_prob *P, int i);
428/* retrieve row scale factor */
429
430double glp_get_sjj(glp_prob *P, int j);
431/* retrieve column scale factor */
432
433void glp_scale_prob(glp_prob *P, int flags);
434/* scale problem data */
435
436void glp_unscale_prob(glp_prob *P);
437/* unscale problem data */
438
439void glp_set_row_stat(glp_prob *P, int i, int stat);
440/* set (change) row status */
441
442void glp_set_col_stat(glp_prob *P, int j, int stat);
443/* set (change) column status */
444
445void glp_std_basis(glp_prob *P);
446/* construct standard initial LP basis */
447
448void glp_adv_basis(glp_prob *P, int flags);
449/* construct advanced initial LP basis */
450
451void glp_cpx_basis(glp_prob *P);
452/* construct Bixby's initial LP basis */
453
454int glp_simplex(glp_prob *P, const glp_smcp *parm);
455/* solve LP problem with the simplex method */
456
457int glp_exact(glp_prob *P, const glp_smcp *parm);
458/* solve LP problem in exact arithmetic */
459
460void glp_init_smcp(glp_smcp *parm);
461/* initialize simplex method control parameters */
462
463int glp_get_status(glp_prob *P);
464/* retrieve generic status of basic solution */
465
466int glp_get_prim_stat(glp_prob *P);
467/* retrieve status of primal basic solution */
468
469int glp_get_dual_stat(glp_prob *P);
470/* retrieve status of dual basic solution */
471
472double glp_get_obj_val(glp_prob *P);
473/* retrieve objective value (basic solution) */
474
475int glp_get_row_stat(glp_prob *P, int i);
476/* retrieve row status */
477
478double glp_get_row_prim(glp_prob *P, int i);
479/* retrieve row primal value (basic solution) */
480
481double glp_get_row_dual(glp_prob *P, int i);
482/* retrieve row dual value (basic solution) */
483
484int glp_get_col_stat(glp_prob *P, int j);
485/* retrieve column status */
486
487double glp_get_col_prim(glp_prob *P, int j);
488/* retrieve column primal value (basic solution) */
489
490double glp_get_col_dual(glp_prob *P, int j);
491/* retrieve column dual value (basic solution) */
492
493int glp_get_unbnd_ray(glp_prob *P);
494/* determine variable causing unboundedness */
495
496int glp_interior(glp_prob *P, const glp_iptcp *parm);
497/* solve LP problem with the interior-point method */
498
499void glp_init_iptcp(glp_iptcp *parm);
500/* initialize interior-point solver control parameters */
501
502int glp_ipt_status(glp_prob *P);
503/* retrieve status of interior-point solution */
504
505double glp_ipt_obj_val(glp_prob *P);
506/* retrieve objective value (interior point) */
507
508double glp_ipt_row_prim(glp_prob *P, int i);
509/* retrieve row primal value (interior point) */
510
511double glp_ipt_row_dual(glp_prob *P, int i);
512/* retrieve row dual value (interior point) */
513
514double glp_ipt_col_prim(glp_prob *P, int j);
515/* retrieve column primal value (interior point) */
516
517double glp_ipt_col_dual(glp_prob *P, int j);
518/* retrieve column dual value (interior point) */
519
520void glp_set_col_kind(glp_prob *P, int j, int kind);
521/* set (change) column kind */
522
523int glp_get_col_kind(glp_prob *P, int j);
524/* retrieve column kind */
525
526int glp_get_num_int(glp_prob *P);
527/* retrieve number of integer columns */
528
529int glp_get_num_bin(glp_prob *P);
530/* retrieve number of binary columns */
531
532int glp_intopt(glp_prob *P, const glp_iocp *parm);
533/* solve MIP problem with the branch-and-bound method */
534
535void glp_init_iocp(glp_iocp *parm);
536/* initialize integer optimizer control parameters */
537
538int glp_mip_status(glp_prob *P);
539/* retrieve status of MIP solution */
540
541double glp_mip_obj_val(glp_prob *P);
542/* retrieve objective value (MIP solution) */
543
544double glp_mip_row_val(glp_prob *P, int i);
545/* retrieve row value (MIP solution) */
546
547double glp_mip_col_val(glp_prob *P, int j);
548/* retrieve column value (MIP solution) */
549
550int glp_print_sol(glp_prob *P, const char *fname);
551/* write basic solution in printable format */
552
553int glp_read_sol(glp_prob *P, const char *fname);
554/* read basic solution from text file */
555
556int glp_write_sol(glp_prob *P, const char *fname);
557/* write basic solution to text file */
558
559int glp_print_ranges(glp_prob *P, int len, const int list[],
560      int flags, const char *fname);
561/* print sensitivity analysis report */
562
563int glp_print_ipt(glp_prob *P, const char *fname);
564/* write interior-point solution in printable format */
565
566int glp_read_ipt(glp_prob *P, const char *fname);
567/* read interior-point solution from text file */
568
569int glp_write_ipt(glp_prob *P, const char *fname);
570/* write interior-point solution to text file */
571
572int glp_print_mip(glp_prob *P, const char *fname);
573/* write MIP solution in printable format */
574
575int glp_read_mip(glp_prob *P, const char *fname);
576/* read MIP solution from text file */
577
578int glp_write_mip(glp_prob *P, const char *fname);
579/* write MIP solution to text file */
580
581int glp_bf_exists(glp_prob *P);
582/* check if the basis factorization exists */
583
584int glp_factorize(glp_prob *P);
585/* compute the basis factorization */
586
587int glp_bf_updated(glp_prob *P);
588/* check if the basis factorization has been updated */
589
590void glp_get_bfcp(glp_prob *P, glp_bfcp *parm);
591/* retrieve basis factorization control parameters */
592
593void glp_set_bfcp(glp_prob *P, const glp_bfcp *parm);
594/* change basis factorization control parameters */
595
596int glp_get_bhead(glp_prob *P, int k);
597/* retrieve the basis header information */
598
599int glp_get_row_bind(glp_prob *P, int i);
600/* retrieve row index in the basis header */
601
602int glp_get_col_bind(glp_prob *P, int j);
603/* retrieve column index in the basis header */
604
605void glp_ftran(glp_prob *P, double x[]);
606/* perform forward transformation (solve system B*x = b) */
607
608void glp_btran(glp_prob *P, double x[]);
609/* perform backward transformation (solve system B'*x = b) */
610
611int glp_warm_up(glp_prob *P);
612/* "warm up" LP basis */
613
614int glp_eval_tab_row(glp_prob *P, int k, int ind[], double val[]);
615/* compute row of the simplex tableau */
616
617int glp_eval_tab_col(glp_prob *P, int k, int ind[], double val[]);
618/* compute column of the simplex tableau */
619
620int glp_transform_row(glp_prob *P, int len, int ind[], double val[]);
621/* transform explicitly specified row */
622
623int glp_transform_col(glp_prob *P, int len, int ind[], double val[]);
624/* transform explicitly specified column */
625
626int 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
630int 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
634void 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
638void 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
642int glp_ios_reason(glp_tree *T);
643/* determine reason for calling the callback routine */
644
645glp_prob *glp_ios_get_prob(glp_tree *T);
646/* access the problem object */
647
648void 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
652int glp_ios_curr_node(glp_tree *T);
653/* determine current active subproblem */
654
655int glp_ios_next_node(glp_tree *T, int p);
656/* determine next active subproblem */
657
658int glp_ios_prev_node(glp_tree *T, int p);
659/* determine previous active subproblem */
660
661int glp_ios_up_node(glp_tree *T, int p);
662/* determine parent subproblem */
663
664int glp_ios_node_level(glp_tree *T, int p);
665/* determine subproblem level */
666
667double glp_ios_node_bound(glp_tree *T, int p);
668/* determine subproblem local bound */
669
670int glp_ios_best_node(glp_tree *T);
671/* find active subproblem with best local bound */
672
673double glp_ios_mip_gap(glp_tree *T);
674/* compute relative MIP gap */
675
676void *glp_ios_node_data(glp_tree *T, int p);
677/* access subproblem application-specific data */
678
679void glp_ios_row_attr(glp_tree *T, int i, glp_attr *attr);
680/* retrieve additional row attributes */
681
682int glp_ios_pool_size(glp_tree *T);
683/* determine current size of the cut pool */
684
685int 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
690void glp_ios_del_row(glp_tree *T, int i);
691/* remove row (constraint) from the cut pool */
692
693void glp_ios_clear_pool(glp_tree *T);
694/* remove all rows (constraints) from the cut pool */
695
696int glp_ios_can_branch(glp_tree *T, int j);
697/* check if can branch upon specified variable */
698
699void glp_ios_branch_upon(glp_tree *T, int j, int sel);
700/* choose variable to branch upon */
701
702void glp_ios_select_node(glp_tree *T, int p);
703/* select subproblem to continue the search */
704
705int glp_ios_heur_sol(glp_tree *T, const double x[]);
706/* provide solution found by heuristic */
707
708void glp_ios_terminate(glp_tree *T);
709/* terminate the solution process */
710
711void glp_init_mpscp(glp_mpscp *parm);
712/* initialize MPS format control parameters */
713
714int glp_read_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
715      const char *fname);
716/* read problem data in MPS format */
717
718int glp_write_mps(glp_prob *P, int fmt, const glp_mpscp *parm,
719      const char *fname);
720/* write problem data in MPS format */
721
722void glp_init_cpxcp(glp_cpxcp *parm);
723/* initialize CPLEX LP format control parameters */
724
725int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
726/* read problem data in CPLEX LP format */
727
728int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname);
729/* write problem data in CPLEX LP format */
730
731int glp_read_prob(glp_prob *P, int flags, const char *fname);
732/* read problem data in GLPK format */
733
734int glp_write_prob(glp_prob *P, int flags, const char *fname);
735/* write problem data in GLPK format */
736
737glp_tran *glp_mpl_alloc_wksp(void);
738/* allocate the MathProg translator workspace */
739
740int glp_mpl_read_model(glp_tran *tran, const char *fname, int skip);
741/* read and translate model section */
742
743int glp_mpl_read_data(glp_tran *tran, const char *fname);
744/* read and translate data section */
745
746int glp_mpl_generate(glp_tran *tran, const char *fname);
747/* generate the model */
748
749void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob);
750/* build LP/MIP problem instance from the model */
751
752int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol);
753/* postsolve the model */
754
755void glp_mpl_free_wksp(glp_tran *tran);
756/* free the MathProg translator workspace */
757
758int glp_main(int argc, const char *argv[]);
759/* stand-alone LP/MIP solver */
760
761/**********************************************************************/
762
763int glp_read_cnfsat(glp_prob *P, const char *fname);
764/* read CNF-SAT problem data in DIMACS format */
765
766int glp_check_cnfsat(glp_prob *P);
767/* check for CNF-SAT problem instance */
768
769int glp_write_cnfsat(glp_prob *P, const char *fname);
770/* write CNF-SAT problem data in DIMACS format */
771
772int glp_minisat1(glp_prob *P);
773/* solve CNF-SAT problem with MiniSat solver */
774
775int 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
782typedef struct { int lo, hi; } glp_long;
783/* long integer data type */
784#endif
785
786int glp_init_env(void);
787/* initialize GLPK environment */
788
789const char *glp_version(void);
790/* determine library version */
791
792int glp_free_env(void);
793/* free GLPK environment */
794
795void glp_printf(const char *fmt, ...);
796/* write formatted output to terminal */
797
798void glp_vprintf(const char *fmt, va_list arg);
799/* write formatted output to terminal */
800
801int glp_term_out(int flag);
802/* enable/disable terminal output */
803
804void glp_term_hook(int (*func)(void *info, const char *s), void *info);
805/* install hook to intercept terminal output */
806
807int glp_open_tee(const char *fname);
808/* start copying terminal output to text file */
809
810int glp_close_tee(void);
811/* stop copying terminal output to text file */
812
813#ifndef GLP_ERROR_DEFINED
814#define GLP_ERROR_DEFINED
815typedef 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)))
824void glp_assert_(const char *expr, const char *file, int line);
825/* check for logical condition */
826
827void glp_error_hook(void (*func)(void *info), void *info);
828/* install hook to intercept abnormal termination */
829
830void *glp_malloc(int size);
831/* allocate memory block */
832
833void *glp_calloc(int n, int size);
834/* allocate memory block */
835
836void glp_free(void *ptr);
837/* free memory block */
838
839void glp_mem_limit(int limit);
840/* set memory usage limit */
841
842void glp_mem_usage(int *count, int *cpeak, glp_long *total,
843      glp_long *tpeak);
844/* get memory usage information */
845
846glp_long glp_time(void);
847/* determine current universal time */
848
849double 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
856typedef struct { double _opaque_data[100]; } glp_data;
857/* plain data file */
858#endif
859
860glp_data *glp_sdf_open_file(const char *fname);
861/* open plain data file */
862
863void glp_sdf_set_jump(glp_data *data, void *jump);
864/* set up error handling */
865
866void glp_sdf_error(glp_data *data, const char *fmt, ...);
867/* print error message */
868
869void glp_sdf_warning(glp_data *data, const char *fmt, ...);
870/* print warning message */
871
872int glp_sdf_read_int(glp_data *data);
873/* read integer number */
874
875double glp_sdf_read_num(glp_data *data);
876/* read floating-point number */
877
878const char *glp_sdf_read_item(glp_data *data);
879/* read data item */
880
881const char *glp_sdf_read_text(glp_data *data);
882/* read text until end of line */
883
884int glp_sdf_line(glp_data *data);
885/* determine current line number */
886
887void glp_sdf_close_file(glp_data *data);
888/* close plain data file */
889
890/**********************************************************************/
891
892typedef struct _glp_graph glp_graph;
893typedef struct _glp_vertex glp_vertex;
894typedef struct _glp_arc glp_arc;
895
896struct _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
920struct _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
941struct _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
961glp_graph *glp_create_graph(int v_size, int a_size);
962/* create graph */
963
964void glp_set_graph_name(glp_graph *G, const char *name);
965/* assign (change) graph name */
966
967int glp_add_vertices(glp_graph *G, int nadd);
968/* add new vertices to graph */
969
970void glp_set_vertex_name(glp_graph *G, int i, const char *name);
971/* assign (change) vertex name */
972
973glp_arc *glp_add_arc(glp_graph *G, int i, int j);
974/* add new arc to graph */
975
976void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
977/* delete vertices from graph */
978
979void glp_del_arc(glp_graph *G, glp_arc *a);
980/* delete arc from graph */
981
982void glp_erase_graph(glp_graph *G, int v_size, int a_size);
983/* erase graph content */
984
985void glp_delete_graph(glp_graph *G);
986/* delete graph */
987
988void glp_create_v_index(glp_graph *G);
989/* create vertex name index */
990
991int glp_find_vertex(glp_graph *G, const char *name);
992/* find vertex by its name */
993
994void glp_delete_v_index(glp_graph *G);
995/* delete vertex name index */
996
997int glp_read_graph(glp_graph *G, const char *fname);
998/* read graph from plain text file */
999
1000int glp_write_graph(glp_graph *G, const char *fname);
1001/* write graph to plain text file */
1002
1003void 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
1007int 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
1011void 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
1015int 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
1019int 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
1027int 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
1031int 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
1035int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
1036/* find bipartite matching of maximum cardinality */
1037
1038double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
1039/* solve critical path problem */
1040
1041int 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
1045int 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
1049int 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
1053int 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
1057int 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
1061int 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
1065int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname);
1066/* read graph in DIMACS clique/coloring format */
1067
1068int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname);
1069/* write graph in DIMACS clique/coloring format */
1070
1071int 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
1075int 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
1079int 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
1083int glp_weak_comp(glp_graph *G, int v_num);
1084/* find all weakly connected components of graph */
1085
1086int glp_strong_comp(glp_graph *G, int v_num);
1087/* find all strongly connected components of graph */
1088
1089int glp_top_sort(glp_graph *G, int v_num);
1090/* topological sorting of acyclic digraph */
1091
1092int 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
1216typedef 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
1303LPX *lpx_create_prob(void);
1304/* create problem object */
1305
1306#define lpx_set_prob_name _glp_lpx_set_prob_name
1307void 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
1311void 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
1315void lpx_set_obj_dir(LPX *lp, int dir);
1316/* set (change) optimization direction flag */
1317
1318#define lpx_add_rows _glp_lpx_add_rows
1319int lpx_add_rows(LPX *lp, int nrs);
1320/* add new rows to problem object */
1321
1322#define lpx_add_cols _glp_lpx_add_cols
1323int 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
1327void 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
1331void 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
1335void 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
1339void 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
1343void 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
1347void 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
1352void 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
1357void 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
1362void 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
1366void 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
1370void lpx_delete_prob(LPX *lp);
1371/* delete problem object */
1372
1373#define lpx_get_prob_name _glp_lpx_get_prob_name
1374const char *lpx_get_prob_name(LPX *lp);
1375/* retrieve problem name */
1376
1377#define lpx_get_obj_name _glp_lpx_get_obj_name
1378const char *lpx_get_obj_name(LPX *lp);
1379/* retrieve objective function name */
1380
1381#define lpx_get_obj_dir _glp_lpx_get_obj_dir
1382int lpx_get_obj_dir(LPX *lp);
1383/* retrieve optimization direction flag */
1384
1385#define lpx_get_num_rows _glp_lpx_get_num_rows
1386int lpx_get_num_rows(LPX *lp);
1387/* retrieve number of rows */
1388
1389#define lpx_get_num_cols _glp_lpx_get_num_cols
1390int lpx_get_num_cols(LPX *lp);
1391/* retrieve number of columns */
1392
1393#define lpx_get_row_name _glp_lpx_get_row_name
1394const 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
1398const 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
1402int lpx_get_row_type(LPX *lp, int i);
1403/* retrieve row type */
1404
1405#define lpx_get_row_lb _glp_lpx_get_row_lb
1406double 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
1410double 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
1414void 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
1419int lpx_get_col_type(LPX *lp, int j);
1420/* retrieve column type */
1421
1422#define lpx_get_col_lb _glp_lpx_get_col_lb
1423double 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
1427double 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
1431void 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
1436double 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
1440int lpx_get_num_nz(LPX *lp);
1441/* retrieve number of constraint coefficients */
1442
1443#define lpx_get_mat_row _glp_lpx_get_mat_row
1444int 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
1448int 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
1452void lpx_create_index(LPX *lp);
1453/* create the name index */
1454
1455#define lpx_find_row _glp_lpx_find_row
1456int lpx_find_row(LPX *lp, const char *name);
1457/* find row by its name */
1458
1459#define lpx_find_col _glp_lpx_find_col
1460int lpx_find_col(LPX *lp, const char *name);
1461/* find column by its name */
1462
1463#define lpx_delete_index _glp_lpx_delete_index
1464void lpx_delete_index(LPX *lp);
1465/* delete the name index */
1466
1467#define lpx_scale_prob _glp_lpx_scale_prob
1468void lpx_scale_prob(LPX *lp);
1469/* scale problem data */
1470
1471#define lpx_unscale_prob _glp_lpx_unscale_prob
1472void lpx_unscale_prob(LPX *lp);
1473/* unscale problem data */
1474
1475#define lpx_set_row_stat _glp_lpx_set_row_stat
1476void 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
1480void 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
1484void lpx_std_basis(LPX *lp);
1485/* construct standard initial LP basis */
1486
1487#define lpx_adv_basis _glp_lpx_adv_basis
1488void lpx_adv_basis(LPX *lp);
1489/* construct advanced initial LP basis */
1490
1491#define lpx_cpx_basis _glp_lpx_cpx_basis
1492void lpx_cpx_basis(LPX *lp);
1493/* construct Bixby's initial LP basis */
1494
1495#define lpx_simplex _glp_lpx_simplex
1496int lpx_simplex(LPX *lp);
1497/* easy-to-use driver to the simplex method */
1498
1499#define lpx_exact _glp_lpx_exact
1500int lpx_exact(LPX *lp);
1501/* easy-to-use driver to the exact simplex method */
1502
1503#define lpx_get_status _glp_lpx_get_status
1504int lpx_get_status(LPX *lp);
1505/* retrieve generic status of basic solution */
1506
1507#define lpx_get_prim_stat _glp_lpx_get_prim_stat
1508int 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
1512int 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
1516double lpx_get_obj_val(LPX *lp);
1517/* retrieve objective value (basic solution) */
1518
1519#define lpx_get_row_stat _glp_lpx_get_row_stat
1520int 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
1524double 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
1528double 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
1532void 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
1537int 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
1541double 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
1545double 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
1549void 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
1554int lpx_get_ray_info(LPX *lp);
1555/* determine what causes primal unboundness */
1556
1557#define lpx_check_kkt _glp_lpx_check_kkt
1558void 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
1562int lpx_warm_up(LPX *lp);
1563/* "warm up" LP basis */
1564
1565#define lpx_eval_tab_row _glp_lpx_eval_tab_row
1566int 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
1570int 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
1574int 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
1578int 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
1582int 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
1587int 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
1592int lpx_interior(LPX *lp);
1593/* easy-to-use driver to the interior point method */
1594
1595#define lpx_ipt_status _glp_lpx_ipt_status
1596int lpx_ipt_status(LPX *lp);
1597/* retrieve status of interior-point solution */
1598
1599#define lpx_ipt_obj_val _glp_lpx_ipt_obj_val
1600double lpx_ipt_obj_val(LPX *lp);
1601/* retrieve objective value (interior point) */
1602
1603#define lpx_ipt_row_prim _glp_lpx_ipt_row_prim
1604double 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
1608double 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
1612double 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
1616double 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
1620void lpx_set_class(LPX *lp, int klass);
1621/* set problem class */
1622
1623#define lpx_get_class _glp_lpx_get_class
1624int lpx_get_class(LPX *lp);
1625/* determine problem klass */
1626
1627#define lpx_set_col_kind _glp_lpx_set_col_kind
1628void 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
1632int lpx_get_col_kind(LPX *lp, int j);
1633/* retrieve column kind */
1634
1635#define lpx_get_num_int _glp_lpx_get_num_int
1636int lpx_get_num_int(LPX *lp);
1637/* retrieve number of integer columns */
1638
1639#define lpx_get_num_bin _glp_lpx_get_num_bin
1640int lpx_get_num_bin(LPX *lp);
1641/* retrieve number of binary columns */
1642
1643#define lpx_integer _glp_lpx_integer
1644int lpx_integer(LPX *lp);
1645/* easy-to-use driver to the branch-and-bound method */
1646
1647#define lpx_intopt _glp_lpx_intopt
1648int 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
1652int lpx_mip_status(LPX *lp);
1653/* retrieve status of MIP solution */
1654
1655#define lpx_mip_obj_val _glp_lpx_mip_obj_val
1656double lpx_mip_obj_val(LPX *lp);
1657/* retrieve objective value (MIP solution) */
1658
1659#define lpx_mip_row_val _glp_lpx_mip_row_val
1660double 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
1664double lpx_mip_col_val(LPX *lp, int j);
1665/* retrieve column value (MIP solution) */
1666
1667#define lpx_check_int _glp_lpx_check_int
1668void lpx_check_int(LPX *lp, LPXKKT *kkt);
1669/* check integer feasibility conditions */
1670
1671#define lpx_reset_parms _glp_lpx_reset_parms
1672void lpx_reset_parms(LPX *lp);
1673/* reset control parameters to default values */
1674
1675#define lpx_set_int_parm _glp_lpx_set_int_parm
1676void 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
1680int 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
1684void 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
1688double lpx_get_real_parm(LPX *lp, int parm);
1689/* query real control parameter */
1690
1691#define lpx_read_mps _glp_lpx_read_mps
1692LPX *lpx_read_mps(const char *fname);
1693/* read problem data in fixed MPS format */
1694
1695#define lpx_write_mps _glp_lpx_write_mps
1696int 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
1700int 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
1704int 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
1708LPX *lpx_read_freemps(const char *fname);
1709/* read problem data in free MPS format */
1710
1711#define lpx_write_freemps _glp_lpx_write_freemps
1712int 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
1716LPX *lpx_read_cpxlp(const char *fname);
1717/* read problem data in CPLEX LP format */
1718
1719#define lpx_write_cpxlp _glp_lpx_write_cpxlp
1720int 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
1724LPX *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
1729int 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
1733int 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
1737int lpx_print_sens_bnds(LPX *lp, const char *fname);
1738/* write bounds sensitivity information */
1739
1740#define lpx_print_ips _glp_lpx_print_ips
1741int 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
1745int 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
1749int lpx_is_b_avail(LPX *lp);
1750/* check if LP basis is available */
1751
1752#define lpx_write_pb _glp_lpx_write_pb
1753int 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
1758int 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.