COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

source: glpk-cmake/include/glpk.h @ 1:c445c931472f

Last change on this file since 1:c445c931472f was 1:c445c931472f, checked in by Alpar Juttner <alpar@…>, 13 years ago

Import glpk-4.45

  • Generated files and doc/notes are removed
File size: 58.7 KB
RevLine 
[1]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 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  45
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
763#ifndef GLP_LONG_DEFINED
764#define GLP_LONG_DEFINED
765typedef struct { int lo, hi; } glp_long;
766/* long integer data type */
767#endif
768
769int glp_init_env(void);
770/* initialize GLPK environment */
771
772const char *glp_version(void);
773/* determine library version */
774
775int glp_free_env(void);
776/* free GLPK environment */
777
778void glp_printf(const char *fmt, ...);
779/* write formatted output to terminal */
780
781void glp_vprintf(const char *fmt, va_list arg);
782/* write formatted output to terminal */
783
784int glp_term_out(int flag);
785/* enable/disable terminal output */
786
787void glp_term_hook(int (*func)(void *info, const char *s), void *info);
788/* install hook to intercept terminal output */
789
790int glp_open_tee(const char *fname);
791/* start copying terminal output to text file */
792
793int glp_close_tee(void);
794/* stop copying terminal output to text file */
795
796#ifndef GLP_ERROR_DEFINED
797#define GLP_ERROR_DEFINED
798typedef void (*_glp_error)(const char *fmt, ...);
799#endif
800
801#define glp_error glp_error_(__FILE__, __LINE__)
802_glp_error glp_error_(const char *file, int line);
803/* display error message and terminate execution */
804
805#define glp_assert(expr) \
806      ((void)((expr) || (glp_assert_(#expr, __FILE__, __LINE__), 1)))
807void glp_assert_(const char *expr, const char *file, int line);
808/* check for logical condition */
809
810void glp_error_hook(void (*func)(void *info), void *info);
811/* install hook to intercept abnormal termination */
812
813void *glp_malloc(int size);
814/* allocate memory block */
815
816void *glp_calloc(int n, int size);
817/* allocate memory block */
818
819void glp_free(void *ptr);
820/* free memory block */
821
822void glp_mem_limit(int limit);
823/* set memory usage limit */
824
825void glp_mem_usage(int *count, int *cpeak, glp_long *total,
826      glp_long *tpeak);
827/* get memory usage information */
828
829glp_long glp_time(void);
830/* determine current universal time */
831
832double glp_difftime(glp_long t1, glp_long t0);
833/* compute difference between two time values */
834
835/**********************************************************************/
836
837#ifndef GLP_DATA_DEFINED
838#define GLP_DATA_DEFINED
839typedef struct { double _opaque_data[100]; } glp_data;
840/* plain data file */
841#endif
842
843glp_data *glp_sdf_open_file(const char *fname);
844/* open plain data file */
845
846void glp_sdf_set_jump(glp_data *data, void *jump);
847/* set up error handling */
848
849void glp_sdf_error(glp_data *data, const char *fmt, ...);
850/* print error message */
851
852void glp_sdf_warning(glp_data *data, const char *fmt, ...);
853/* print warning message */
854
855int glp_sdf_read_int(glp_data *data);
856/* read integer number */
857
858double glp_sdf_read_num(glp_data *data);
859/* read floating-point number */
860
861const char *glp_sdf_read_item(glp_data *data);
862/* read data item */
863
864const char *glp_sdf_read_text(glp_data *data);
865/* read text until end of line */
866
867int glp_sdf_line(glp_data *data);
868/* determine current line number */
869
870void glp_sdf_close_file(glp_data *data);
871/* close plain data file */
872
873/**********************************************************************/
874
875typedef struct _glp_graph glp_graph;
876typedef struct _glp_vertex glp_vertex;
877typedef struct _glp_arc glp_arc;
878
879struct _glp_graph
880{     /* graph descriptor */
881      void *pool; /* DMP *pool; */
882      /* memory pool to store graph components */
883      char *name;
884      /* graph name (1 to 255 chars); NULL means no name is assigned
885         to the graph */
886      int nv_max;
887      /* length of the vertex list (enlarged automatically) */
888      int nv;
889      /* number of vertices in the graph, 0 <= nv <= nv_max */
890      int na;
891      /* number of arcs in the graph, na >= 0 */
892      glp_vertex **v; /* glp_vertex *v[1+nv_max]; */
893      /* v[i], 1 <= i <= nv, is a pointer to i-th vertex */
894      void *index; /* AVL *index; */
895      /* vertex index to find vertices by their names; NULL means the
896         index does not exist */
897      int v_size;
898      /* size of data associated with each vertex (0 to 256 bytes) */
899      int a_size;
900      /* size of data associated with each arc (0 to 256 bytes) */
901};
902
903struct _glp_vertex
904{     /* vertex descriptor */
905      int i;
906      /* vertex ordinal number, 1 <= i <= nv */
907      char *name;
908      /* vertex name (1 to 255 chars); NULL means no name is assigned
909         to the vertex */
910      void *entry; /* AVLNODE *entry; */
911      /* pointer to corresponding entry in the vertex index; NULL means
912         that either the index does not exist or the vertex has no name
913         assigned */
914      void *data;
915      /* pointer to data associated with the vertex */
916      void *temp;
917      /* working pointer */
918      glp_arc *in;
919      /* pointer to the (unordered) list of incoming arcs */
920      glp_arc *out;
921      /* pointer to the (unordered) list of outgoing arcs */
922};
923
924struct _glp_arc
925{     /* arc descriptor */
926      glp_vertex *tail;
927      /* pointer to the tail endpoint */
928      glp_vertex *head;
929      /* pointer to the head endpoint */
930      void *data;
931      /* pointer to data associated with the arc */
932      void *temp;
933      /* working pointer */
934      glp_arc *t_prev;
935      /* pointer to previous arc having the same tail endpoint */
936      glp_arc *t_next;
937      /* pointer to next arc having the same tail endpoint */
938      glp_arc *h_prev;
939      /* pointer to previous arc having the same head endpoint */
940      glp_arc *h_next;
941      /* pointer to next arc having the same head endpoint */
942};
943
944glp_graph *glp_create_graph(int v_size, int a_size);
945/* create graph */
946
947void glp_set_graph_name(glp_graph *G, const char *name);
948/* assign (change) graph name */
949
950int glp_add_vertices(glp_graph *G, int nadd);
951/* add new vertices to graph */
952
953void glp_set_vertex_name(glp_graph *G, int i, const char *name);
954/* assign (change) vertex name */
955
956glp_arc *glp_add_arc(glp_graph *G, int i, int j);
957/* add new arc to graph */
958
959void glp_del_vertices(glp_graph *G, int ndel, const int num[]);
960/* delete vertices from graph */
961
962void glp_del_arc(glp_graph *G, glp_arc *a);
963/* delete arc from graph */
964
965void glp_erase_graph(glp_graph *G, int v_size, int a_size);
966/* erase graph content */
967
968void glp_delete_graph(glp_graph *G);
969/* delete graph */
970
971void glp_create_v_index(glp_graph *G);
972/* create vertex name index */
973
974int glp_find_vertex(glp_graph *G, const char *name);
975/* find vertex by its name */
976
977void glp_delete_v_index(glp_graph *G);
978/* delete vertex name index */
979
980int glp_read_graph(glp_graph *G, const char *fname);
981/* read graph from plain text file */
982
983int glp_write_graph(glp_graph *G, const char *fname);
984/* write graph to plain text file */
985
986void glp_mincost_lp(glp_prob *P, glp_graph *G, int names, int v_rhs,
987      int a_low, int a_cap, int a_cost);
988/* convert minimum cost flow problem to LP */
989
990int glp_mincost_okalg(glp_graph *G, int v_rhs, int a_low, int a_cap,
991      int a_cost, double *sol, int a_x, int v_pi);
992/* find minimum-cost flow with out-of-kilter algorithm */
993
994void glp_maxflow_lp(glp_prob *P, glp_graph *G, int names, int s,
995      int t, int a_cap);
996/* convert maximum flow problem to LP */
997
998int glp_maxflow_ffalg(glp_graph *G, int s, int t, int a_cap,
999      double *sol, int a_x, int v_cut);
1000/* find maximal flow with Ford-Fulkerson algorithm */
1001
1002int glp_check_asnprob(glp_graph *G, int v_set);
1003/* check correctness of assignment problem data */
1004
1005/* assignment problem formulation: */
1006#define GLP_ASN_MIN        1  /* perfect matching (minimization) */
1007#define GLP_ASN_MAX        2  /* perfect matching (maximization) */
1008#define GLP_ASN_MMP        3  /* maximum matching */
1009
1010int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
1011      int v_set, int a_cost);
1012/* convert assignment problem to LP */
1013
1014int glp_asnprob_okalg(int form, glp_graph *G, int v_set, int a_cost,
1015      double *sol, int a_x);
1016/* solve assignment problem with out-of-kilter algorithm */
1017
1018int glp_asnprob_hall(glp_graph *G, int v_set, int a_x);
1019/* find bipartite matching of maximum cardinality */
1020
1021double glp_cpp(glp_graph *G, int v_t, int v_es, int v_ls);
1022/* solve critical path problem */
1023
1024int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1025      int a_cost, const char *fname);
1026/* read min-cost flow problem data in DIMACS format */
1027
1028int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
1029      int a_cost, const char *fname);
1030/* write min-cost flow problem data in DIMACS format */
1031
1032int glp_read_maxflow(glp_graph *G, int *s, int *t, int a_cap,
1033      const char *fname);
1034/* read maximum flow problem data in DIMACS format */
1035
1036int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
1037      const char *fname);
1038/* write maximum flow problem data in DIMACS format */
1039
1040int glp_read_asnprob(glp_graph *G, int v_set, int a_cost, const char
1041      *fname);
1042/* read assignment problem data in DIMACS format */
1043
1044int glp_write_asnprob(glp_graph *G, int v_set, int a_cost, const char
1045      *fname);
1046/* write assignment problem data in DIMACS format */
1047
1048int glp_read_ccdata(glp_graph *G, int v_wgt, const char *fname);
1049/* read graph in DIMACS clique/coloring format */
1050
1051int glp_write_ccdata(glp_graph *G, int v_wgt, const char *fname);
1052/* write graph in DIMACS clique/coloring format */
1053
1054int glp_netgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1055      const int parm[1+15]);
1056/* Klingman's network problem generator */
1057
1058int glp_gridgen(glp_graph *G, int v_rhs, int a_cap, int a_cost,
1059      const int parm[1+14]);
1060/* grid-like network problem generator */
1061
1062int glp_rmfgen(glp_graph *G, int *s, int *t, int a_cap,
1063      const int parm[1+5]);
1064/* Goldfarb's maximum flow problem generator */
1065
1066int glp_weak_comp(glp_graph *G, int v_num);
1067/* find all weakly connected components of graph */
1068
1069int glp_strong_comp(glp_graph *G, int v_num);
1070/* find all strongly connected components of graph */
1071
1072int glp_top_sort(glp_graph *G, int v_num);
1073/* topological sorting of acyclic digraph */
1074
1075int glp_wclique_exact(glp_graph *G, int v_wgt, double *sol, int v_set);
1076/* find maximum weight clique with exact algorithm */
1077
1078/***********************************************************************
1079*  NOTE: All symbols defined below are obsolete and kept here only for
1080*        backward compatibility.
1081***********************************************************************/
1082
1083#define LPX glp_prob
1084
1085/* problem class: */
1086#define LPX_LP          100   /* linear programming (LP) */
1087#define LPX_MIP         101   /* mixed integer programming (MIP) */
1088
1089/* type of auxiliary/structural variable: */
1090#define LPX_FR          110   /* free variable */
1091#define LPX_LO          111   /* variable with lower bound */
1092#define LPX_UP          112   /* variable with upper bound */
1093#define LPX_DB          113   /* double-bounded variable */
1094#define LPX_FX          114   /* fixed variable */
1095
1096/* optimization direction flag: */
1097#define LPX_MIN         120   /* minimization */
1098#define LPX_MAX         121   /* maximization */
1099
1100/* status of primal basic solution: */
1101#define LPX_P_UNDEF     132   /* primal solution is undefined */
1102#define LPX_P_FEAS      133   /* solution is primal feasible */
1103#define LPX_P_INFEAS    134   /* solution is primal infeasible */
1104#define LPX_P_NOFEAS    135   /* no primal feasible solution exists */
1105
1106/* status of dual basic solution: */
1107#define LPX_D_UNDEF     136   /* dual solution is undefined */
1108#define LPX_D_FEAS      137   /* solution is dual feasible */
1109#define LPX_D_INFEAS    138   /* solution is dual infeasible */
1110#define LPX_D_NOFEAS    139   /* no dual feasible solution exists */
1111
1112/* status of auxiliary/structural variable: */
1113#define LPX_BS          140   /* basic variable */
1114#define LPX_NL          141   /* non-basic variable on lower bound */
1115#define LPX_NU          142   /* non-basic variable on upper bound */
1116#define LPX_NF          143   /* non-basic free variable */
1117#define LPX_NS          144   /* non-basic fixed variable */
1118
1119/* status of interior-point solution: */
1120#define LPX_T_UNDEF     150   /* interior solution is undefined */
1121#define LPX_T_OPT       151   /* interior solution is optimal */
1122
1123/* kind of structural variable: */
1124#define LPX_CV          160   /* continuous variable */
1125#define LPX_IV          161   /* integer variable */
1126
1127/* status of integer solution: */
1128#define LPX_I_UNDEF     170   /* integer solution is undefined */
1129#define LPX_I_OPT       171   /* integer solution is optimal */
1130#define LPX_I_FEAS      172   /* integer solution is feasible */
1131#define LPX_I_NOFEAS    173   /* no integer solution exists */
1132
1133/* status codes reported by the routine lpx_get_status: */
1134#define LPX_OPT         180   /* optimal */
1135#define LPX_FEAS        181   /* feasible */
1136#define LPX_INFEAS      182   /* infeasible */
1137#define LPX_NOFEAS      183   /* no feasible */
1138#define LPX_UNBND       184   /* unbounded */
1139#define LPX_UNDEF       185   /* undefined */
1140
1141/* exit codes returned by solver routines: */
1142#define LPX_E_OK        200   /* success */
1143#define LPX_E_EMPTY     201   /* empty problem */
1144#define LPX_E_BADB      202   /* invalid initial basis */
1145#define LPX_E_INFEAS    203   /* infeasible initial solution */
1146#define LPX_E_FAULT     204   /* unable to start the search */
1147#define LPX_E_OBJLL     205   /* objective lower limit reached */
1148#define LPX_E_OBJUL     206   /* objective upper limit reached */
1149#define LPX_E_ITLIM     207   /* iterations limit exhausted */
1150#define LPX_E_TMLIM     208   /* time limit exhausted */
1151#define LPX_E_NOFEAS    209   /* no feasible solution */
1152#define LPX_E_INSTAB    210   /* numerical instability */
1153#define LPX_E_SING      211   /* problems with basis matrix */
1154#define LPX_E_NOCONV    212   /* no convergence (interior) */
1155#define LPX_E_NOPFS     213   /* no primal feas. sol. (LP presolver) */
1156#define LPX_E_NODFS     214   /* no dual feas. sol. (LP presolver) */
1157#define LPX_E_MIPGAP    215   /* relative mip gap tolerance reached */
1158
1159/* control parameter identifiers: */
1160#define LPX_K_MSGLEV    300   /* lp->msg_lev */
1161#define LPX_K_SCALE     301   /* lp->scale */
1162#define LPX_K_DUAL      302   /* lp->dual */
1163#define LPX_K_PRICE     303   /* lp->price */
1164#define LPX_K_RELAX     304   /* lp->relax */
1165#define LPX_K_TOLBND    305   /* lp->tol_bnd */
1166#define LPX_K_TOLDJ     306   /* lp->tol_dj */
1167#define LPX_K_TOLPIV    307   /* lp->tol_piv */
1168#define LPX_K_ROUND     308   /* lp->round */
1169#define LPX_K_OBJLL     309   /* lp->obj_ll */
1170#define LPX_K_OBJUL     310   /* lp->obj_ul */
1171#define LPX_K_ITLIM     311   /* lp->it_lim */
1172#define LPX_K_ITCNT     312   /* lp->it_cnt */
1173#define LPX_K_TMLIM     313   /* lp->tm_lim */
1174#define LPX_K_OUTFRQ    314   /* lp->out_frq */
1175#define LPX_K_OUTDLY    315   /* lp->out_dly */
1176#define LPX_K_BRANCH    316   /* lp->branch */
1177#define LPX_K_BTRACK    317   /* lp->btrack */
1178#define LPX_K_TOLINT    318   /* lp->tol_int */
1179#define LPX_K_TOLOBJ    319   /* lp->tol_obj */
1180#define LPX_K_MPSINFO   320   /* lp->mps_info */
1181#define LPX_K_MPSOBJ    321   /* lp->mps_obj */
1182#define LPX_K_MPSORIG   322   /* lp->mps_orig */
1183#define LPX_K_MPSWIDE   323   /* lp->mps_wide */
1184#define LPX_K_MPSFREE   324   /* lp->mps_free */
1185#define LPX_K_MPSSKIP   325   /* lp->mps_skip */
1186#define LPX_K_LPTORIG   326   /* lp->lpt_orig */
1187#define LPX_K_PRESOL    327   /* lp->presol */
1188#define LPX_K_BINARIZE  328   /* lp->binarize */
1189#define LPX_K_USECUTS   329   /* lp->use_cuts */
1190#define LPX_K_BFTYPE    330   /* lp->bfcp->type */
1191#define LPX_K_MIPGAP    331   /* lp->mip_gap */
1192
1193#define LPX_C_COVER     0x01  /* mixed cover cuts */
1194#define LPX_C_CLIQUE    0x02  /* clique cuts */
1195#define LPX_C_GOMORY    0x04  /* Gomory's mixed integer cuts */
1196#define LPX_C_MIR       0x08  /* mixed integer rounding cuts */
1197#define LPX_C_ALL       0xFF  /* all cuts */
1198
1199typedef struct
1200{     /* this structure contains results reported by the routines which
1201         checks Karush-Kuhn-Tucker conditions (for details see comments
1202         to those routines) */
1203      /*--------------------------------------------------------------*/
1204      /* xR - A * xS = 0 (KKT.PE) */
1205      double pe_ae_max;
1206      /* largest absolute error */
1207      int    pe_ae_row;
1208      /* number of row with largest absolute error */
1209      double pe_re_max;
1210      /* largest relative error */
1211      int    pe_re_row;
1212      /* number of row with largest relative error */
1213      int    pe_quality;
1214      /* quality of primal solution:
1215         'H' - high
1216         'M' - medium
1217         'L' - low
1218         '?' - primal solution is wrong */
1219      /*--------------------------------------------------------------*/
1220      /* l[k] <= x[k] <= u[k] (KKT.PB) */
1221      double pb_ae_max;
1222      /* largest absolute error */
1223      int    pb_ae_ind;
1224      /* number of variable with largest absolute error */
1225      double pb_re_max;
1226      /* largest relative error */
1227      int    pb_re_ind;
1228      /* number of variable with largest relative error */
1229      int    pb_quality;
1230      /* quality of primal feasibility:
1231         'H' - high
1232         'M' - medium
1233         'L' - low
1234         '?' - primal solution is infeasible */
1235      /*--------------------------------------------------------------*/
1236      /* A' * (dR - cR) + (dS - cS) = 0 (KKT.DE) */
1237      double de_ae_max;
1238      /* largest absolute error */
1239      int    de_ae_col;
1240      /* number of column with largest absolute error */
1241      double de_re_max;
1242      /* largest relative error */
1243      int    de_re_col;
1244      /* number of column with largest relative error */
1245      int    de_quality;
1246      /* quality of dual solution:
1247         'H' - high
1248         'M' - medium
1249         'L' - low
1250         '?' - dual solution is wrong */
1251      /*--------------------------------------------------------------*/
1252      /* d[k] >= 0 or d[k] <= 0 (KKT.DB) */
1253      double db_ae_max;
1254      /* largest absolute error */
1255      int    db_ae_ind;
1256      /* number of variable with largest absolute error */
1257      double db_re_max;
1258      /* largest relative error */
1259      int    db_re_ind;
1260      /* number of variable with largest relative error */
1261      int    db_quality;
1262      /* quality of dual feasibility:
1263         'H' - high
1264         'M' - medium
1265         'L' - low
1266         '?' - dual solution is infeasible */
1267      /*--------------------------------------------------------------*/
1268      /* (x[k] - bound of x[k]) * d[k] = 0 (KKT.CS) */
1269      double cs_ae_max;
1270      /* largest absolute error */
1271      int    cs_ae_ind;
1272      /* number of variable with largest absolute error */
1273      double cs_re_max;
1274      /* largest relative error */
1275      int    cs_re_ind;
1276      /* number of variable with largest relative error */
1277      int    cs_quality;
1278      /* quality of complementary slackness:
1279         'H' - high
1280         'M' - medium
1281         'L' - low
1282         '?' - primal and dual solutions are not complementary */
1283} LPXKKT;
1284
1285#define lpx_create_prob _glp_lpx_create_prob
1286LPX *lpx_create_prob(void);
1287/* create problem object */
1288
1289#define lpx_set_prob_name _glp_lpx_set_prob_name
1290void lpx_set_prob_name(LPX *lp, const char *name);
1291/* assign (change) problem name */
1292
1293#define lpx_set_obj_name _glp_lpx_set_obj_name
1294void lpx_set_obj_name(LPX *lp, const char *name);
1295/* assign (change) objective function name */
1296
1297#define lpx_set_obj_dir _glp_lpx_set_obj_dir
1298void lpx_set_obj_dir(LPX *lp, int dir);
1299/* set (change) optimization direction flag */
1300
1301#define lpx_add_rows _glp_lpx_add_rows
1302int lpx_add_rows(LPX *lp, int nrs);
1303/* add new rows to problem object */
1304
1305#define lpx_add_cols _glp_lpx_add_cols
1306int lpx_add_cols(LPX *lp, int ncs);
1307/* add new columns to problem object */
1308
1309#define lpx_set_row_name _glp_lpx_set_row_name
1310void lpx_set_row_name(LPX *lp, int i, const char *name);
1311/* assign (change) row name */
1312
1313#define lpx_set_col_name _glp_lpx_set_col_name
1314void lpx_set_col_name(LPX *lp, int j, const char *name);
1315/* assign (change) column name */
1316
1317#define lpx_set_row_bnds _glp_lpx_set_row_bnds
1318void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub);
1319/* set (change) row bounds */
1320
1321#define lpx_set_col_bnds _glp_lpx_set_col_bnds
1322void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub);
1323/* set (change) column bounds */
1324
1325#define lpx_set_obj_coef _glp_lpx_set_obj_coef
1326void lpx_set_obj_coef(glp_prob *lp, int j, double coef);
1327/* set (change) obj. coefficient or constant term */
1328
1329#define lpx_set_mat_row _glp_lpx_set_mat_row
1330void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
1331      const double val[]);
1332/* set (replace) row of the constraint matrix */
1333
1334#define lpx_set_mat_col _glp_lpx_set_mat_col
1335void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
1336      const double val[]);
1337/* set (replace) column of the constraint matrix */
1338
1339#define lpx_load_matrix _glp_lpx_load_matrix
1340void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
1341      const double ar[]);
1342/* load (replace) the whole constraint matrix */
1343
1344#define lpx_del_rows _glp_lpx_del_rows
1345void lpx_del_rows(LPX *lp, int nrs, const int num[]);
1346/* delete specified rows from problem object */
1347
1348#define lpx_del_cols _glp_lpx_del_cols
1349void lpx_del_cols(LPX *lp, int ncs, const int num[]);
1350/* delete specified columns from problem object */
1351
1352#define lpx_delete_prob _glp_lpx_delete_prob
1353void lpx_delete_prob(LPX *lp);
1354/* delete problem object */
1355
1356#define lpx_get_prob_name _glp_lpx_get_prob_name
1357const char *lpx_get_prob_name(LPX *lp);
1358/* retrieve problem name */
1359
1360#define lpx_get_obj_name _glp_lpx_get_obj_name
1361const char *lpx_get_obj_name(LPX *lp);
1362/* retrieve objective function name */
1363
1364#define lpx_get_obj_dir _glp_lpx_get_obj_dir
1365int lpx_get_obj_dir(LPX *lp);
1366/* retrieve optimization direction flag */
1367
1368#define lpx_get_num_rows _glp_lpx_get_num_rows
1369int lpx_get_num_rows(LPX *lp);
1370/* retrieve number of rows */
1371
1372#define lpx_get_num_cols _glp_lpx_get_num_cols
1373int lpx_get_num_cols(LPX *lp);
1374/* retrieve number of columns */
1375
1376#define lpx_get_row_name _glp_lpx_get_row_name
1377const char *lpx_get_row_name(LPX *lp, int i);
1378/* retrieve row name */
1379
1380#define lpx_get_col_name _glp_lpx_get_col_name
1381const char *lpx_get_col_name(LPX *lp, int j);
1382/* retrieve column name */
1383
1384#define lpx_get_row_type _glp_lpx_get_row_type
1385int lpx_get_row_type(LPX *lp, int i);
1386/* retrieve row type */
1387
1388#define lpx_get_row_lb _glp_lpx_get_row_lb
1389double lpx_get_row_lb(LPX *lp, int i);
1390/* retrieve row lower bound */
1391
1392#define lpx_get_row_ub _glp_lpx_get_row_ub
1393double lpx_get_row_ub(LPX *lp, int i);
1394/* retrieve row upper bound */
1395
1396#define lpx_get_row_bnds _glp_lpx_get_row_bnds
1397void lpx_get_row_bnds(LPX *lp, int i, int *typx, double *lb,
1398      double *ub);
1399/* retrieve row bounds */
1400
1401#define lpx_get_col_type _glp_lpx_get_col_type
1402int lpx_get_col_type(LPX *lp, int j);
1403/* retrieve column type */
1404
1405#define lpx_get_col_lb _glp_lpx_get_col_lb
1406double lpx_get_col_lb(LPX *lp, int j);
1407/* retrieve column lower bound */
1408
1409#define lpx_get_col_ub _glp_lpx_get_col_ub
1410double lpx_get_col_ub(LPX *lp, int j);
1411/* retrieve column upper bound */
1412
1413#define lpx_get_col_bnds _glp_lpx_get_col_bnds
1414void lpx_get_col_bnds(LPX *lp, int j, int *typx, double *lb,
1415      double *ub);
1416/* retrieve column bounds */
1417
1418#define lpx_get_obj_coef _glp_lpx_get_obj_coef
1419double lpx_get_obj_coef(LPX *lp, int j);
1420/* retrieve obj. coefficient or constant term */
1421
1422#define lpx_get_num_nz _glp_lpx_get_num_nz
1423int lpx_get_num_nz(LPX *lp);
1424/* retrieve number of constraint coefficients */
1425
1426#define lpx_get_mat_row _glp_lpx_get_mat_row
1427int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[]);
1428/* retrieve row of the constraint matrix */
1429
1430#define lpx_get_mat_col _glp_lpx_get_mat_col
1431int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[]);
1432/* retrieve column of the constraint matrix */
1433
1434#define lpx_create_index _glp_lpx_create_index
1435void lpx_create_index(LPX *lp);
1436/* create the name index */
1437
1438#define lpx_find_row _glp_lpx_find_row
1439int lpx_find_row(LPX *lp, const char *name);
1440/* find row by its name */
1441
1442#define lpx_find_col _glp_lpx_find_col
1443int lpx_find_col(LPX *lp, const char *name);
1444/* find column by its name */
1445
1446#define lpx_delete_index _glp_lpx_delete_index
1447void lpx_delete_index(LPX *lp);
1448/* delete the name index */
1449
1450#define lpx_scale_prob _glp_lpx_scale_prob
1451void lpx_scale_prob(LPX *lp);
1452/* scale problem data */
1453
1454#define lpx_unscale_prob _glp_lpx_unscale_prob
1455void lpx_unscale_prob(LPX *lp);
1456/* unscale problem data */
1457
1458#define lpx_set_row_stat _glp_lpx_set_row_stat
1459void lpx_set_row_stat(LPX *lp, int i, int stat);
1460/* set (change) row status */
1461
1462#define lpx_set_col_stat _glp_lpx_set_col_stat
1463void lpx_set_col_stat(LPX *lp, int j, int stat);
1464/* set (change) column status */
1465
1466#define lpx_std_basis _glp_lpx_std_basis
1467void lpx_std_basis(LPX *lp);
1468/* construct standard initial LP basis */
1469
1470#define lpx_adv_basis _glp_lpx_adv_basis
1471void lpx_adv_basis(LPX *lp);
1472/* construct advanced initial LP basis */
1473
1474#define lpx_cpx_basis _glp_lpx_cpx_basis
1475void lpx_cpx_basis(LPX *lp);
1476/* construct Bixby's initial LP basis */
1477
1478#define lpx_simplex _glp_lpx_simplex
1479int lpx_simplex(LPX *lp);
1480/* easy-to-use driver to the simplex method */
1481
1482#define lpx_exact _glp_lpx_exact
1483int lpx_exact(LPX *lp);
1484/* easy-to-use driver to the exact simplex method */
1485
1486#define lpx_get_status _glp_lpx_get_status
1487int lpx_get_status(LPX *lp);
1488/* retrieve generic status of basic solution */
1489
1490#define lpx_get_prim_stat _glp_lpx_get_prim_stat
1491int lpx_get_prim_stat(LPX *lp);
1492/* retrieve primal status of basic solution */
1493
1494#define lpx_get_dual_stat _glp_lpx_get_dual_stat
1495int lpx_get_dual_stat(LPX *lp);
1496/* retrieve dual status of basic solution */
1497
1498#define lpx_get_obj_val _glp_lpx_get_obj_val
1499double lpx_get_obj_val(LPX *lp);
1500/* retrieve objective value (basic solution) */
1501
1502#define lpx_get_row_stat _glp_lpx_get_row_stat
1503int lpx_get_row_stat(LPX *lp, int i);
1504/* retrieve row status (basic solution) */
1505
1506#define lpx_get_row_prim _glp_lpx_get_row_prim
1507double lpx_get_row_prim(LPX *lp, int i);
1508/* retrieve row primal value (basic solution) */
1509
1510#define lpx_get_row_dual _glp_lpx_get_row_dual
1511double lpx_get_row_dual(LPX *lp, int i);
1512/* retrieve row dual value (basic solution) */
1513
1514#define lpx_get_row_info _glp_lpx_get_row_info
1515void lpx_get_row_info(LPX *lp, int i, int *tagx, double *vx,
1516      double *dx);
1517/* obtain row solution information */
1518
1519#define lpx_get_col_stat _glp_lpx_get_col_stat
1520int lpx_get_col_stat(LPX *lp, int j);
1521/* retrieve column status (basic solution) */
1522
1523#define lpx_get_col_prim _glp_lpx_get_col_prim
1524double lpx_get_col_prim(LPX *lp, int j);
1525/* retrieve column primal value (basic solution) */
1526
1527#define lpx_get_col_dual _glp_lpx_get_col_dual
1528double lpx_get_col_dual(glp_prob *lp, int j);
1529/* retrieve column dual value (basic solution) */
1530
1531#define lpx_get_col_info _glp_lpx_get_col_info
1532void lpx_get_col_info(LPX *lp, int j, int *tagx, double *vx,
1533      double *dx);
1534/* obtain column solution information (obsolete) */
1535
1536#define lpx_get_ray_info _glp_lpx_get_ray_info
1537int lpx_get_ray_info(LPX *lp);
1538/* determine what causes primal unboundness */
1539
1540#define lpx_check_kkt _glp_lpx_check_kkt
1541void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt);
1542/* check Karush-Kuhn-Tucker conditions */
1543
1544#define lpx_warm_up _glp_lpx_warm_up
1545int lpx_warm_up(LPX *lp);
1546/* "warm up" LP basis */
1547
1548#define lpx_eval_tab_row _glp_lpx_eval_tab_row
1549int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[]);
1550/* compute row of the simplex table */
1551
1552#define lpx_eval_tab_col _glp_lpx_eval_tab_col
1553int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[]);
1554/* compute column of the simplex table */
1555
1556#define lpx_transform_row _glp_lpx_transform_row
1557int lpx_transform_row(LPX *lp, int len, int ind[], double val[]);
1558/* transform explicitly specified row */
1559
1560#define lpx_transform_col _glp_lpx_transform_col
1561int lpx_transform_col(LPX *lp, int len, int ind[], double val[]);
1562/* transform explicitly specified column */
1563
1564#define lpx_prim_ratio_test _glp_lpx_prim_ratio_test
1565int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
1566      const double val[], int how, double tol);
1567/* perform primal ratio test */
1568
1569#define lpx_dual_ratio_test _glp_lpx_dual_ratio_test
1570int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
1571      const double val[], int how, double tol);
1572/* perform dual ratio test */
1573
1574#define lpx_interior _glp_lpx_interior
1575int lpx_interior(LPX *lp);
1576/* easy-to-use driver to the interior point method */
1577
1578#define lpx_ipt_status _glp_lpx_ipt_status
1579int lpx_ipt_status(LPX *lp);
1580/* retrieve status of interior-point solution */
1581
1582#define lpx_ipt_obj_val _glp_lpx_ipt_obj_val
1583double lpx_ipt_obj_val(LPX *lp);
1584/* retrieve objective value (interior point) */
1585
1586#define lpx_ipt_row_prim _glp_lpx_ipt_row_prim
1587double lpx_ipt_row_prim(LPX *lp, int i);
1588/* retrieve row primal value (interior point) */
1589
1590#define lpx_ipt_row_dual _glp_lpx_ipt_row_dual
1591double lpx_ipt_row_dual(LPX *lp, int i);
1592/* retrieve row dual value (interior point) */
1593
1594#define lpx_ipt_col_prim _glp_lpx_ipt_col_prim
1595double lpx_ipt_col_prim(LPX *lp, int j);
1596/* retrieve column primal value (interior point) */
1597
1598#define lpx_ipt_col_dual _glp_lpx_ipt_col_dual
1599double lpx_ipt_col_dual(LPX *lp, int j);
1600/* retrieve column dual value (interior point) */
1601
1602#define lpx_set_class _glp_lpx_set_class
1603void lpx_set_class(LPX *lp, int klass);
1604/* set problem class */
1605
1606#define lpx_get_class _glp_lpx_get_class
1607int lpx_get_class(LPX *lp);
1608/* determine problem klass */
1609
1610#define lpx_set_col_kind _glp_lpx_set_col_kind
1611void lpx_set_col_kind(LPX *lp, int j, int kind);
1612/* set (change) column kind */
1613
1614#define lpx_get_col_kind _glp_lpx_get_col_kind
1615int lpx_get_col_kind(LPX *lp, int j);
1616/* retrieve column kind */
1617
1618#define lpx_get_num_int _glp_lpx_get_num_int
1619int lpx_get_num_int(LPX *lp);
1620/* retrieve number of integer columns */
1621
1622#define lpx_get_num_bin _glp_lpx_get_num_bin
1623int lpx_get_num_bin(LPX *lp);
1624/* retrieve number of binary columns */
1625
1626#define lpx_integer _glp_lpx_integer
1627int lpx_integer(LPX *lp);
1628/* easy-to-use driver to the branch-and-bound method */
1629
1630#define lpx_intopt _glp_lpx_intopt
1631int lpx_intopt(LPX *lp);
1632/* easy-to-use driver to the branch-and-bound method */
1633
1634#define lpx_mip_status _glp_lpx_mip_status
1635int lpx_mip_status(LPX *lp);
1636/* retrieve status of MIP solution */
1637
1638#define lpx_mip_obj_val _glp_lpx_mip_obj_val
1639double lpx_mip_obj_val(LPX *lp);
1640/* retrieve objective value (MIP solution) */
1641
1642#define lpx_mip_row_val _glp_lpx_mip_row_val
1643double lpx_mip_row_val(LPX *lp, int i);
1644/* retrieve row value (MIP solution) */
1645
1646#define lpx_mip_col_val _glp_lpx_mip_col_val
1647double lpx_mip_col_val(LPX *lp, int j);
1648/* retrieve column value (MIP solution) */
1649
1650#define lpx_check_int _glp_lpx_check_int
1651void lpx_check_int(LPX *lp, LPXKKT *kkt);
1652/* check integer feasibility conditions */
1653
1654#define lpx_reset_parms _glp_lpx_reset_parms
1655void lpx_reset_parms(LPX *lp);
1656/* reset control parameters to default values */
1657
1658#define lpx_set_int_parm _glp_lpx_set_int_parm
1659void lpx_set_int_parm(LPX *lp, int parm, int val);
1660/* set (change) integer control parameter */
1661
1662#define lpx_get_int_parm _glp_lpx_get_int_parm
1663int lpx_get_int_parm(LPX *lp, int parm);
1664/* query integer control parameter */
1665
1666#define lpx_set_real_parm _glp_lpx_set_real_parm
1667void lpx_set_real_parm(LPX *lp, int parm, double val);
1668/* set (change) real control parameter */
1669
1670#define lpx_get_real_parm _glp_lpx_get_real_parm
1671double lpx_get_real_parm(LPX *lp, int parm);
1672/* query real control parameter */
1673
1674#define lpx_read_mps _glp_lpx_read_mps
1675LPX *lpx_read_mps(const char *fname);
1676/* read problem data in fixed MPS format */
1677
1678#define lpx_write_mps _glp_lpx_write_mps
1679int lpx_write_mps(LPX *lp, const char *fname);
1680/* write problem data in fixed MPS format */
1681
1682#define lpx_read_bas _glp_lpx_read_bas
1683int lpx_read_bas(LPX *lp, const char *fname);
1684/* read LP basis in fixed MPS format */
1685
1686#define lpx_write_bas _glp_lpx_write_bas
1687int lpx_write_bas(LPX *lp, const char *fname);
1688/* write LP basis in fixed MPS format */
1689
1690#define lpx_read_freemps _glp_lpx_read_freemps
1691LPX *lpx_read_freemps(const char *fname);
1692/* read problem data in free MPS format */
1693
1694#define lpx_write_freemps _glp_lpx_write_freemps
1695int lpx_write_freemps(LPX *lp, const char *fname);
1696/* write problem data in free MPS format */
1697
1698#define lpx_read_cpxlp _glp_lpx_read_cpxlp
1699LPX *lpx_read_cpxlp(const char *fname);
1700/* read problem data in CPLEX LP format */
1701
1702#define lpx_write_cpxlp _glp_lpx_write_cpxlp
1703int lpx_write_cpxlp(LPX *lp, const char *fname);
1704/* write problem data in CPLEX LP format */
1705
1706#define lpx_read_model _glp_lpx_read_model
1707LPX *lpx_read_model(const char *model, const char *data,
1708      const char *output);
1709/* read LP/MIP model written in GNU MathProg language */
1710
1711#define lpx_print_prob _glp_lpx_print_prob
1712int lpx_print_prob(LPX *lp, const char *fname);
1713/* write problem data in plain text format */
1714
1715#define lpx_print_sol _glp_lpx_print_sol
1716int lpx_print_sol(LPX *lp, const char *fname);
1717/* write LP problem solution in printable format */
1718
1719#define lpx_print_sens_bnds _glp_lpx_print_sens_bnds
1720int lpx_print_sens_bnds(LPX *lp, const char *fname);
1721/* write bounds sensitivity information */
1722
1723#define lpx_print_ips _glp_lpx_print_ips
1724int lpx_print_ips(LPX *lp, const char *fname);
1725/* write interior point solution in printable format */
1726
1727#define lpx_print_mip _glp_lpx_print_mip
1728int lpx_print_mip(LPX *lp, const char *fname);
1729/* write MIP problem solution in printable format */
1730
1731#define lpx_is_b_avail _glp_lpx_is_b_avail
1732int lpx_is_b_avail(LPX *lp);
1733/* check if LP basis is available */
1734
1735#define lpx_write_pb _glp_lpx_write_pb
1736int lpx_write_pb(LPX *lp, const char *fname, int normalized,
1737      int binarize);
1738/* write problem data in (normalized) OPB format */
1739
1740#define lpx_main _glp_lpx_main
1741int lpx_main(int argc, const char *argv[]);
1742/* stand-alone LP/MIP solver */
1743
1744#ifdef __cplusplus
1745}
1746#endif
1747
1748#endif
1749
1750/* eof */
Note: See TracBrowser for help on using the repository browser.