libmove3d
3.13.0
|
00001 /* glpk.h */ 00002 00003 /*********************************************************************** 00004 * This code is part of GLPK (GNU Linear Programming Kit). 00005 * 00006 * Copyright (C) 2000, 01, 02, 03, 04, 05, 06, 07, 08 Andrew Makhorin, 00007 * Department for Applied Informatics, Moscow Aviation Institute, 00008 * Moscow, Russia. All rights reserved. E-mail: <mao@mai2.rcnet.ru>. 00009 * 00010 * GLPK is free software: you can redistribute it and/or modify it 00011 * under the terms of the GNU General Public License as published by 00012 * the Free Software Foundation, either version 3 of the License, or 00013 * (at your option) any later version. 00014 * 00015 * GLPK is distributed in the hope that it will be useful, but WITHOUT 00016 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 00017 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 00018 * License for more details. 00019 * 00020 * You should have received a copy of the GNU General Public License 00021 * along with GLPK. If not, see <http://www.gnu.org/licenses/>. 00022 ***********************************************************************/ 00023 00024 #ifndef _GLPK_H 00025 #define _GLPK_H 00026 00027 #ifdef __cplusplus 00028 extern "C" { 00029 #endif 00030 00031 /* library version numbers: */ 00032 #define GLP_MAJOR_VERSION 4 00033 #define GLP_MINOR_VERSION 28 00034 00035 #ifndef _GLP_PROB 00036 #define _GLP_PROB 00037 typedef struct { double _prob; } glp_prob; 00038 /* LP/MIP problem object */ 00039 #endif 00040 00041 /* optimization direction flag: */ 00042 #define GLP_MIN 1 /* minimization */ 00043 #define GLP_MAX 2 /* maximization */ 00044 00045 /* kind of structural variable: */ 00046 #define GLP_CV 1 /* continuous variable */ 00047 #define GLP_IV 2 /* integer variable */ 00048 #define GLP_BV 3 /* binary variable */ 00049 00050 /* type of auxiliary/structural variable: */ 00051 #define GLP_FR 1 /* free variable */ 00052 #define GLP_LO 2 /* variable with lower bound */ 00053 #define GLP_UP 3 /* variable with upper bound */ 00054 #define GLP_DB 4 /* double-bounded variable */ 00055 #define GLP_FX 5 /* fixed variable */ 00056 00057 /* status of auxiliary/structural variable: */ 00058 #define GLP_BS 1 /* basic variable */ 00059 #define GLP_NL 2 /* non-basic variable on lower bound */ 00060 #define GLP_NU 3 /* non-basic variable on upper bound */ 00061 #define GLP_NF 4 /* non-basic free variable */ 00062 #define GLP_NS 5 /* non-basic fixed variable */ 00063 00064 /* solution status: */ 00065 #define GLP_UNDEF 1 /* solution is undefined */ 00066 #define GLP_FEAS 2 /* solution is feasible */ 00067 #define GLP_INFEAS 3 /* solution is infeasible */ 00068 #define GLP_NOFEAS 4 /* no feasible solution exists */ 00069 #define GLP_OPT 5 /* solution is optimal */ 00070 #define GLP_UNBND 6 /* solution is unbounded */ 00071 00072 typedef struct { int lo, hi; } glp_long; 00073 /* long integer data type */ 00074 00075 #ifndef _GLP_BFCP 00076 #define _GLP_BFCP 00077 typedef struct glp_bfcp glp_bfcp; 00078 #endif 00079 00080 struct glp_bfcp 00081 { /* basis factorization control parameters */ 00082 int msg_lev; /* (reserved) */ 00083 int type; /* factorization type: */ 00084 #define GLP_BF_FT 1 /* LUF + Forrest-Tomlin */ 00085 #define GLP_BF_BG 2 /* LUF + Schur compl. + Bartels-Golub */ 00086 #define GLP_BF_GR 3 /* LUF + Schur compl. + Givens rotation */ 00087 int lu_size; /* luf.sv_size */ 00088 double piv_tol; /* luf.piv_tol */ 00089 int piv_lim; /* luf.piv_lim */ 00090 int suhl; /* luf.suhl */ 00091 double eps_tol; /* luf.eps_tol */ 00092 double max_gro; /* luf.max_gro */ 00093 int nfs_max; /* fhv.hh_max */ 00094 double upd_tol; /* fhv.upd_tol */ 00095 int nrs_max; /* lpf.n_max */ 00096 int rs_size; /* lpf.v_size */ 00097 double foo_bar[38]; /* (reserved) */ 00098 }; 00099 00100 typedef struct 00101 { /* simplex method control parameters */ 00102 int msg_lev; /* message level: */ 00103 #define GLP_MSG_OFF 0 /* no output */ 00104 #define GLP_MSG_ERR 1 /* warning and error messages only */ 00105 #define GLP_MSG_ON 2 /* normal output */ 00106 #define GLP_MSG_ALL 3 /* full output */ 00107 int meth; /* simplex method option: */ 00108 #define GLP_PRIMAL 1 /* use primal simplex */ 00109 #define GLP_DUALP 2 /* use dual simplex, if possible */ 00110 int pricing; /* pricing technique: */ 00111 #define GLP_PT_STD 0x11 /* standard (textbook) */ 00112 #define GLP_PT_PSE 0x22 /* projected steepest edge */ 00113 int r_test; /* ratio test technique: */ 00114 #define GLP_RT_STD 0x11 /* standard (textbook) */ 00115 #define GLP_RT_HAR 0x22 /* Harris' ratio test */ 00116 double tol_bnd; /* spx.tol_bnd */ 00117 double tol_dj; /* spx.tol_dj */ 00118 double tol_piv; /* spx.tol_piv */ 00119 double obj_ll; /* spx.obj_ll */ 00120 double obj_ul; /* spx.obj_ul */ 00121 int it_lim; /* spx.it_lim */ 00122 int tm_lim; /* spx.tm_lim (milliseconds) */ 00123 int out_frq; /* spx.out_frq */ 00124 int out_dly; /* spx.out_dly (milliseconds) */ 00125 int presolve; /* enable/disable using LP presolver */ 00126 double foo_bar[36]; /* (reserved) */ 00127 } glp_smcp; 00128 00129 #ifndef _GLP_TREE 00130 #define _GLP_TREE 00131 typedef struct { double _tree; } glp_tree; 00132 /* branch-and-bound tree */ 00133 #endif 00134 00135 typedef struct 00136 { /* integer optimizer control parameters */ 00137 int msg_lev; /* message level: */ 00138 #define GLP_MSG_OFF 0 /* no output */ 00139 #define GLP_MSG_ERR 1 /* warning and error messages only */ 00140 #define GLP_MSG_ON 2 /* normal output */ 00141 #define GLP_MSG_ALL 3 /* full output */ 00142 #define GLP_MSG_DBG 4 /* debug output */ 00143 int br_tech; /* branching technique: */ 00144 #define GLP_BR_FFV 1 /* first fractional variable */ 00145 #define GLP_BR_LFV 2 /* last fractional variable */ 00146 #define GLP_BR_MFV 3 /* most fractional variable */ 00147 #define GLP_BR_DTH 4 /* heuristic by Driebeck and Tomlin */ 00148 int bt_tech; /* backtracking technique: */ 00149 #define GLP_BT_DFS 1 /* depth first search */ 00150 #define GLP_BT_BFS 2 /* breadth first search */ 00151 #define GLP_BT_BLB 3 /* best local bound */ 00152 #define GLP_BT_BPH 4 /* best projection heuristic */ 00153 double tol_int; /* mip.tol_int */ 00154 double tol_obj; /* mip.tol_obj */ 00155 int tm_lim; /* mip.tm_lim (milliseconds) */ 00156 int out_frq; /* mip.out_frq (milliseconds) */ 00157 int out_dly; /* mip.out_dly (milliseconds) */ 00158 void (*cb_func)(glp_tree *tree, void *info); 00159 /* mip.cb_func */ 00160 void *cb_info; /* mip.cb_info */ 00161 int cb_size; /* mip.cb_size */ 00162 int pp_tech; /* preprocessing technique: */ 00163 #define GLP_PP_NONE 0 /* disable preprocessing */ 00164 #define GLP_PP_ROOT 1 /* preprocessing only on root level */ 00165 #define GLP_PP_ALL 2 /* preprocessing on all levels */ 00166 double mip_gap; /* relative MIP gap tolerance */ 00167 int mir_cuts; /* MIR cuts (GLP_ON/GLP_OFF) */ 00168 int gmi_cuts; /* Gomory's cuts (GLP_ON/GLP_OFF) */ 00169 double foo_bar[34]; /* (reserved) */ 00170 #if 1 /* not yet available */ 00171 char *fn_sol; /* file name to write solution found */ 00172 #endif 00173 } glp_iocp; 00174 00175 /* enable/disable flag: */ 00176 #define GLP_ON 1 /* enable something */ 00177 #define GLP_OFF 0 /* disable something */ 00178 00179 /* reason codes: */ 00180 #define GLP_IROWGEN 0x01 /* request for row generation */ 00181 #define GLP_IBINGO 0x02 /* better integer solution found */ 00182 #define GLP_IHEUR 0x03 /* request for heuristic solution */ 00183 #define GLP_ICUTGEN 0x04 /* request for cut generation */ 00184 #define GLP_IBRANCH 0x05 /* request for branching */ 00185 #define GLP_ISELECT 0x06 /* request for subproblem selection */ 00186 #define GLP_IPREPRO 0x07 /* request for preprocessing */ 00187 00188 /* return codes: */ 00189 #define GLP_EBADB 0x01 /* invalid basis */ 00190 #define GLP_ESING 0x02 /* singular matrix */ 00191 #define GLP_ECOND 0x03 /* ill-conditioned matrix */ 00192 #define GLP_EBOUND 0x04 /* invalid bounds */ 00193 #define GLP_EFAIL 0x05 /* solver failed */ 00194 #define GLP_EOBJLL 0x06 /* objective lower limit reached */ 00195 #define GLP_EOBJUL 0x07 /* objective upper limit reached */ 00196 #define GLP_EITLIM 0x08 /* iteration limit exceeded */ 00197 #define GLP_ETMLIM 0x09 /* time limit exceeded */ 00198 #define GLP_ENOPFS 0x0A /* no primal feasible solution */ 00199 #define GLP_ENODFS 0x0B /* no dual feasible solution */ 00200 #define GLP_EROOT 0x0C /* root LP optimum not provided */ 00201 #define GLP_ESTOP 0x0D /* serach terminated by application */ 00202 00203 glp_prob *glp_create_prob(void); 00204 /* create problem object */ 00205 00206 void glp_set_prob_name(glp_prob *lp, const char *name); 00207 /* assign (change) problem name */ 00208 00209 void glp_set_obj_name(glp_prob *lp, const char *name); 00210 /* assign (change) objective function name */ 00211 00212 void glp_set_obj_dir(glp_prob *lp, int dir); 00213 /* set (change) optimization direction flag */ 00214 00215 int glp_add_rows(glp_prob *lp, int nrs); 00216 /* add new rows to problem object */ 00217 00218 int glp_add_cols(glp_prob *lp, int ncs); 00219 /* add new columns to problem object */ 00220 00221 void glp_set_row_name(glp_prob *lp, int i, const char *name); 00222 /* assign (change) row name */ 00223 00224 void glp_set_col_name(glp_prob *lp, int j, const char *name); 00225 /* assign (change) column name */ 00226 00227 void glp_set_row_bnds(glp_prob *lp, int i, int type, double lb, 00228 double ub); 00229 /* set (change) row bounds */ 00230 00231 void glp_set_col_bnds(glp_prob *lp, int j, int type, double lb, 00232 double ub); 00233 /* set (change) column bounds */ 00234 00235 void glp_set_obj_coef(glp_prob *lp, int j, double coef); 00236 /* set (change) obj. coefficient or constant term */ 00237 00238 void glp_set_mat_row(glp_prob *lp, int i, int len, const int ind[], 00239 const double val[]); 00240 /* set (replace) row of the constraint matrix */ 00241 00242 void glp_set_mat_col(glp_prob *lp, int j, int len, const int ind[], 00243 const double val[]); 00244 /* set (replace) column of the constraint matrix */ 00245 00246 void glp_load_matrix(glp_prob *lp, int ne, const int ia[], 00247 const int ja[], const double ar[]); 00248 /* load (replace) the whole constraint matrix */ 00249 00250 void glp_del_rows(glp_prob *lp, int nrs, const int num[]); 00251 /* delete specified rows from problem object */ 00252 00253 void glp_del_cols(glp_prob *lp, int ncs, const int num[]); 00254 /* delete specified columns from problem object */ 00255 00256 void glp_delete_prob(glp_prob *lp); 00257 /* delete problem object */ 00258 00259 const char *glp_get_prob_name(glp_prob *lp); 00260 /* retrieve problem name */ 00261 00262 const char *glp_get_obj_name(glp_prob *lp); 00263 /* retrieve objective function name */ 00264 00265 int glp_get_obj_dir(glp_prob *lp); 00266 /* retrieve optimization direction flag */ 00267 00268 int glp_get_num_rows(glp_prob *lp); 00269 /* retrieve number of rows */ 00270 00271 int glp_get_num_cols(glp_prob *lp); 00272 /* retrieve number of columns */ 00273 00274 const char *glp_get_row_name(glp_prob *lp, int i); 00275 /* retrieve row name */ 00276 00277 const char *glp_get_col_name(glp_prob *lp, int j); 00278 /* retrieve column name */ 00279 00280 int glp_get_row_type(glp_prob *lp, int i); 00281 /* retrieve row type */ 00282 00283 double glp_get_row_lb(glp_prob *lp, int i); 00284 /* retrieve row lower bound */ 00285 00286 double glp_get_row_ub(glp_prob *lp, int i); 00287 /* retrieve row upper bound */ 00288 00289 int glp_get_col_type(glp_prob *lp, int j); 00290 /* retrieve column type */ 00291 00292 double glp_get_col_lb(glp_prob *lp, int j); 00293 /* retrieve column lower bound */ 00294 00295 double glp_get_col_ub(glp_prob *lp, int j); 00296 /* retrieve column upper bound */ 00297 00298 double glp_get_obj_coef(glp_prob *lp, int j); 00299 /* retrieve obj. coefficient or constant term */ 00300 00301 int glp_get_num_nz(glp_prob *lp); 00302 /* retrieve number of constraint coefficients */ 00303 00304 int glp_get_mat_row(glp_prob *lp, int i, int ind[], double val[]); 00305 /* retrieve row of the constraint matrix */ 00306 00307 int glp_get_mat_col(glp_prob *lp, int j, int ind[], double val[]); 00308 /* retrieve column of the constraint matrix */ 00309 00310 void glp_create_index(glp_prob *lp); 00311 /* create the name index */ 00312 00313 int glp_find_row(glp_prob *lp, const char *name); 00314 /* find row by its name */ 00315 00316 int glp_find_col(glp_prob *lp, const char *name); 00317 /* find column by its name */ 00318 00319 void glp_delete_index(glp_prob *lp); 00320 /* delete the name index */ 00321 00322 void glp_set_rii(glp_prob *lp, int i, double rii); 00323 /* set (change) row scale factor */ 00324 00325 void glp_set_sjj(glp_prob *lp, int j, double sjj); 00326 /* set (change) column scale factor */ 00327 00328 double glp_get_rii(glp_prob *lp, int i); 00329 /* retrieve row scale factor */ 00330 00331 double glp_get_sjj(glp_prob *lp, int j); 00332 /* retrieve column scale factor */ 00333 00334 void glp_unscale_prob(glp_prob *lp); 00335 /* unscale problem data */ 00336 00337 void glp_set_row_stat(glp_prob *lp, int i, int stat); 00338 /* set (change) row status */ 00339 00340 void glp_set_col_stat(glp_prob *lp, int j, int stat); 00341 /* set (change) column status */ 00342 00343 int glp_simplex(glp_prob *lp, const glp_smcp *parm); 00344 /* solve LP problem with the simplex method */ 00345 00346 void glp_init_smcp(glp_smcp *parm); 00347 /* initialize simplex method control parameters */ 00348 00349 int glp_get_row_stat(glp_prob *lp, int i); 00350 /* retrieve row status */ 00351 00352 int glp_get_col_stat(glp_prob *lp, int j); 00353 /* retrieve column status */ 00354 00355 int glp_get_status(glp_prob *lp); 00356 /* retrieve generic status of basic solution */ 00357 00358 int glp_get_prim_stat(glp_prob *lp); 00359 /* retrieve status of primal basic solution */ 00360 00361 int glp_get_dual_stat(glp_prob *lp); 00362 /* retrieve status of dual basic solution */ 00363 00364 double glp_get_obj_val(glp_prob *lp); 00365 /* retrieve objective value (basic solution) */ 00366 00367 double glp_get_row_prim(glp_prob *lp, int i); 00368 /* retrieve row primal value (basic solution) */ 00369 00370 double glp_get_row_dual(glp_prob *lp, int i); 00371 /* retrieve row dual value (basic solution) */ 00372 00373 double glp_get_col_prim(glp_prob *lp, int j); 00374 /* retrieve column primal value (basic solution) */ 00375 00376 double glp_get_col_dual(glp_prob *lp, int j); 00377 /* retrieve column dual value (basic solution) */ 00378 00379 int glp_ipt_status(glp_prob *lp); 00380 /* retrieve status of interior-point solution */ 00381 00382 double glp_ipt_obj_val(glp_prob *lp); 00383 /* retrieve objective value (interior point) */ 00384 00385 double glp_ipt_row_prim(glp_prob *lp, int i); 00386 /* retrieve row primal value (interior point) */ 00387 00388 double glp_ipt_row_dual(glp_prob *lp, int i); 00389 /* retrieve row dual value (interior point) */ 00390 00391 double glp_ipt_col_prim(glp_prob *lp, int j); 00392 /* retrieve column primal value (interior point) */ 00393 00394 double glp_ipt_col_dual(glp_prob *lp, int j); 00395 /* retrieve column dual value (interior point) */ 00396 00397 void glp_set_col_kind(glp_prob *mip, int j, int kind); 00398 /* set (change) column kind */ 00399 00400 int glp_get_col_kind(glp_prob *mip, int j); 00401 /* retrieve column kind */ 00402 00403 int glp_get_num_int(glp_prob *mip); 00404 /* retrieve number of integer columns */ 00405 00406 int glp_get_num_bin(glp_prob *mip); 00407 /* retrieve number of binary columns */ 00408 00409 int glp_intopt(glp_prob *mip, const glp_iocp *parm); 00410 /* solve MIP problem with the branch-and-bound method */ 00411 00412 void glp_init_iocp(glp_iocp *parm); 00413 /* initialize integer optimizer control parameters */ 00414 00415 int glp_mip_status(glp_prob *mip); 00416 /* retrieve status of MIP solution */ 00417 00418 double glp_mip_obj_val(glp_prob *mip); 00419 /* retrieve objective value (MIP solution) */ 00420 00421 double glp_mip_row_val(glp_prob *mip, int i); 00422 /* retrieve row value (MIP solution) */ 00423 00424 double glp_mip_col_val(glp_prob *mip, int j); 00425 /* retrieve column value (MIP solution) */ 00426 00427 int glp_read_sol(glp_prob *lp, const char *fname); 00428 /* read basic solution from text file */ 00429 00430 int glp_write_sol(glp_prob *lp, const char *fname); 00431 /* write basic solution to text file */ 00432 00433 int glp_read_ipt(glp_prob *lp, const char *fname); 00434 /* read interior-point solution from text file */ 00435 00436 int glp_write_ipt(glp_prob *lp, const char *fname); 00437 /* write interior-point solution to text file */ 00438 00439 int glp_read_mip(glp_prob *mip, const char *fname); 00440 /* read MIP solution from text file */ 00441 00442 int glp_write_mip(glp_prob *mip, const char *fname); 00443 /* write MIP solution to text file */ 00444 00445 int glp_bf_exists(glp_prob *lp); 00446 /* check if the basis factorization exists */ 00447 00448 int glp_factorize(glp_prob *lp); 00449 /* compute the basis factorization */ 00450 00451 int glp_bf_updated(glp_prob *lp); 00452 /* check if the basis factorization has been updated */ 00453 00454 void glp_get_bfcp(glp_prob *lp, glp_bfcp *parm); 00455 /* retrieve basis factorization control parameters */ 00456 00457 void glp_set_bfcp(glp_prob *lp, const glp_bfcp *parm); 00458 /* change basis factorization control parameters */ 00459 00460 int glp_get_bhead(glp_prob *lp, int k); 00461 /* retrieve the basis header information */ 00462 00463 int glp_get_row_bind(glp_prob *lp, int i); 00464 /* retrieve row index in the basis header */ 00465 00466 int glp_get_col_bind(glp_prob *lp, int j); 00467 /* retrieve column index in the basis header */ 00468 00469 void glp_ftran(glp_prob *lp, double x[]); 00470 /* perform forward transformation (solve system B*x = b) */ 00471 00472 void glp_btran(glp_prob *lp, double x[]); 00473 /* perform backward transformation (solve system B'*x = b) */ 00474 00475 int glp_eval_tab_row(glp_prob *lp, int k, int ind[], double val[]); 00476 /* compute row of the simplex tableau */ 00477 00478 int glp_eval_tab_col(glp_prob *lp, int k, int ind[], double val[]); 00479 /* compute column of the simplex tableau */ 00480 00481 int glp_ios_reason(glp_tree *tree); 00482 /* determine reason for calling the callback routine */ 00483 00484 glp_prob *glp_ios_get_prob(glp_tree *tree); 00485 /* access the problem object */ 00486 00487 void glp_ios_tree_size(glp_tree *tree, int *a_cnt, int *n_cnt, 00488 int *t_cnt); 00489 /* determine size of the branch-and-bound tree */ 00490 00491 int glp_ios_curr_node(glp_tree *tree); 00492 /* determine current active subproblem */ 00493 00494 int glp_ios_next_node(glp_tree *tree, int p); 00495 /* determine next active subproblem */ 00496 00497 int glp_ios_prev_node(glp_tree *tree, int p); 00498 /* determine previous active subproblem */ 00499 00500 int glp_ios_up_node(glp_tree *tree, int p); 00501 /* determine parent subproblem */ 00502 00503 int glp_ios_node_level(glp_tree *tree, int p); 00504 /* determine subproblem level */ 00505 00506 double glp_ios_node_bound(glp_tree *tree, int p); 00507 /* determine subproblem local bound */ 00508 00509 int glp_ios_best_node(glp_tree *tree); 00510 /* find active subproblem with best local bound */ 00511 00512 double glp_ios_mip_gap(glp_tree *tree); 00513 /* compute relative MIP gap */ 00514 00515 void *glp_ios_node_data(glp_tree *tree, int p); 00516 /* access subproblem application-specific data */ 00517 00518 int glp_ios_can_branch(glp_tree *tree, int j); 00519 /* check if can branch upon specified variable */ 00520 00521 void glp_ios_branch_upon(glp_tree *tree, int j, int sel); 00522 /* choose variable to branch upon */ 00523 00524 void glp_ios_select_node(glp_tree *tree, int p); 00525 /* select subproblem to continue the search */ 00526 00527 int glp_ios_heur_sol(glp_tree *tree, const double x[]); 00528 /* provide solution found by heuristic */ 00529 00530 void glp_ios_terminate(glp_tree *tree); 00531 /* terminate the solution process */ 00532 00533 const char *glp_version(void); 00534 /* determine library version */ 00535 00536 void glp_term_out(int flag); 00537 /* enable/disable terminal output */ 00538 00539 void glp_term_hook(int (*func)(void *info, const char *s), void *info); 00540 /* install hook to intercept terminal output */ 00541 00542 void *glp_malloc(int size); 00543 /* allocate memory block */ 00544 00545 void *glp_calloc(int n, int size); 00546 /* allocate memory block */ 00547 00548 void glp_free(void *ptr); 00549 /* free memory block */ 00550 00551 void glp_mem_usage(int *count, int *cpeak, glp_long *total, 00552 glp_long *tpeak); 00553 /* get memory usage information */ 00554 00555 void glp_mem_limit(int limit); 00556 /* set memory usage limit */ 00557 00558 void glp_free_env(void); 00559 /* free GLPK library environment */ 00560 00561 int glp_main(int argc, const char *argv[]); 00562 /* stand-alone LP/MIP solver */ 00563 00564 /**********************************************************************/ 00565 00566 #define LPX glp_prob 00567 00568 /* problem class: */ 00569 #define LPX_LP 100 /* linear programming (LP) */ 00570 #define LPX_MIP 101 /* mixed integer programming (MIP) */ 00571 00572 /* type of auxiliary/structural variable: */ 00573 #define LPX_FR 110 /* free variable */ 00574 #define LPX_LO 111 /* variable with lower bound */ 00575 #define LPX_UP 112 /* variable with upper bound */ 00576 #define LPX_DB 113 /* double-bounded variable */ 00577 #define LPX_FX 114 /* fixed variable */ 00578 00579 /* optimization direction flag: */ 00580 #define LPX_MIN 120 /* minimization */ 00581 #define LPX_MAX 121 /* maximization */ 00582 00583 /* status of primal basic solution: */ 00584 #define LPX_P_UNDEF 132 /* primal solution is undefined */ 00585 #define LPX_P_FEAS 133 /* solution is primal feasible */ 00586 #define LPX_P_INFEAS 134 /* solution is primal infeasible */ 00587 #define LPX_P_NOFEAS 135 /* no primal feasible solution exists */ 00588 00589 /* status of dual basic solution: */ 00590 #define LPX_D_UNDEF 136 /* dual solution is undefined */ 00591 #define LPX_D_FEAS 137 /* solution is dual feasible */ 00592 #define LPX_D_INFEAS 138 /* solution is dual infeasible */ 00593 #define LPX_D_NOFEAS 139 /* no dual feasible solution exists */ 00594 00595 /* status of auxiliary/structural variable: */ 00596 #define LPX_BS 140 /* basic variable */ 00597 #define LPX_NL 141 /* non-basic variable on lower bound */ 00598 #define LPX_NU 142 /* non-basic variable on upper bound */ 00599 #define LPX_NF 143 /* non-basic free variable */ 00600 #define LPX_NS 144 /* non-basic fixed variable */ 00601 00602 /* status of interior-point solution: */ 00603 #define LPX_T_UNDEF 150 /* interior solution is undefined */ 00604 #define LPX_T_OPT 151 /* interior solution is optimal */ 00605 00606 /* kind of structural variable: */ 00607 #define LPX_CV 160 /* continuous variable */ 00608 #define LPX_IV 161 /* integer variable */ 00609 00610 /* status of integer solution: */ 00611 #define LPX_I_UNDEF 170 /* integer solution is undefined */ 00612 #define LPX_I_OPT 171 /* integer solution is optimal */ 00613 #define LPX_I_FEAS 172 /* integer solution is feasible */ 00614 #define LPX_I_NOFEAS 173 /* no integer solution exists */ 00615 00616 /* status codes reported by the routine lpx_get_status: */ 00617 #define LPX_OPT 180 /* optimal */ 00618 #define LPX_FEAS 181 /* feasible */ 00619 #define LPX_INFEAS 182 /* infeasible */ 00620 #define LPX_NOFEAS 183 /* no feasible */ 00621 #define LPX_UNBND 184 /* unbounded */ 00622 #define LPX_UNDEF 185 /* undefined */ 00623 00624 /* exit codes returned by solver routines: */ 00625 #define LPX_E_OK 200 /* success */ 00626 #define LPX_E_EMPTY 201 /* empty problem */ 00627 #define LPX_E_BADB 202 /* invalid initial basis */ 00628 #define LPX_E_INFEAS 203 /* infeasible initial solution */ 00629 #define LPX_E_FAULT 204 /* unable to start the search */ 00630 #define LPX_E_OBJLL 205 /* objective lower limit reached */ 00631 #define LPX_E_OBJUL 206 /* objective upper limit reached */ 00632 #define LPX_E_ITLIM 207 /* iterations limit exhausted */ 00633 #define LPX_E_TMLIM 208 /* time limit exhausted */ 00634 #define LPX_E_NOFEAS 209 /* no feasible solution */ 00635 #define LPX_E_INSTAB 210 /* numerical instability */ 00636 #define LPX_E_SING 211 /* problems with basis matrix */ 00637 #define LPX_E_NOCONV 212 /* no convergence (interior) */ 00638 #define LPX_E_NOPFS 213 /* no primal feas. sol. (LP presolver) */ 00639 #define LPX_E_NODFS 214 /* no dual feas. sol. (LP presolver) */ 00640 00641 /* control parameter identifiers: */ 00642 #define LPX_K_MSGLEV 300 /* lp->msg_lev */ 00643 #define LPX_K_SCALE 301 /* lp->scale */ 00644 #define LPX_K_DUAL 302 /* lp->dual */ 00645 #define LPX_K_PRICE 303 /* lp->price */ 00646 #define LPX_K_RELAX 304 /* lp->relax */ 00647 #define LPX_K_TOLBND 305 /* lp->tol_bnd */ 00648 #define LPX_K_TOLDJ 306 /* lp->tol_dj */ 00649 #define LPX_K_TOLPIV 307 /* lp->tol_piv */ 00650 #define LPX_K_ROUND 308 /* lp->round */ 00651 #define LPX_K_OBJLL 309 /* lp->obj_ll */ 00652 #define LPX_K_OBJUL 310 /* lp->obj_ul */ 00653 #define LPX_K_ITLIM 311 /* lp->it_lim */ 00654 #define LPX_K_ITCNT 312 /* lp->it_cnt */ 00655 #define LPX_K_TMLIM 313 /* lp->tm_lim */ 00656 #define LPX_K_OUTFRQ 314 /* lp->out_frq */ 00657 #define LPX_K_OUTDLY 315 /* lp->out_dly */ 00658 #define LPX_K_BRANCH 316 /* lp->branch */ 00659 #define LPX_K_BTRACK 317 /* lp->btrack */ 00660 #define LPX_K_TOLINT 318 /* lp->tol_int */ 00661 #define LPX_K_TOLOBJ 319 /* lp->tol_obj */ 00662 #define LPX_K_MPSINFO 320 /* lp->mps_info */ 00663 #define LPX_K_MPSOBJ 321 /* lp->mps_obj */ 00664 #define LPX_K_MPSORIG 322 /* lp->mps_orig */ 00665 #define LPX_K_MPSWIDE 323 /* lp->mps_wide */ 00666 #define LPX_K_MPSFREE 324 /* lp->mps_free */ 00667 #define LPX_K_MPSSKIP 325 /* lp->mps_skip */ 00668 #define LPX_K_LPTORIG 326 /* lp->lpt_orig */ 00669 #define LPX_K_PRESOL 327 /* lp->presol */ 00670 #define LPX_K_BINARIZE 328 /* lp->binarize */ 00671 #define LPX_K_USECUTS 329 /* lp->use_cuts */ 00672 #define LPX_K_BFTYPE 330 /* lp->bfcp->type */ 00673 #define LPX_K_MIPGAP 331 /* lp->mip_gap */ 00674 00675 #define LPX_C_COVER 0x01 /* mixed cover cuts */ 00676 #define LPX_C_CLIQUE 0x02 /* clique cuts */ 00677 #define LPX_C_GOMORY 0x04 /* Gomory's mixed integer cuts */ 00678 #define LPX_C_MIR 0x08 /* mixed integer rounding cuts */ 00679 #define LPX_C_ALL 0xFF /* all cuts */ 00680 00681 typedef struct 00682 { /* this structure contains results reported by the routines which 00683 checks Karush-Kuhn-Tucker conditions (for details see comments 00684 to those routines) */ 00685 /*--------------------------------------------------------------*/ 00686 /* xR - A * xS = 0 (KKT.PE) */ 00687 double pe_ae_max; 00688 /* largest absolute error */ 00689 int pe_ae_row; 00690 /* number of row with largest absolute error */ 00691 double pe_re_max; 00692 /* largest relative error */ 00693 int pe_re_row; 00694 /* number of row with largest relative error */ 00695 int pe_quality; 00696 /* quality of primal solution: 00697 'H' - high 00698 'M' - medium 00699 'L' - low 00700 '?' - primal solution is wrong */ 00701 /*--------------------------------------------------------------*/ 00702 /* l[k] <= x[k] <= u[k] (KKT.PB) */ 00703 double pb_ae_max; 00704 /* largest absolute error */ 00705 int pb_ae_ind; 00706 /* number of variable with largest absolute error */ 00707 double pb_re_max; 00708 /* largest relative error */ 00709 int pb_re_ind; 00710 /* number of variable with largest relative error */ 00711 int pb_quality; 00712 /* quality of primal feasibility: 00713 'H' - high 00714 'M' - medium 00715 'L' - low 00716 '?' - primal solution is infeasible */ 00717 /*--------------------------------------------------------------*/ 00718 /* A' * (dR - cR) + (dS - cS) = 0 (KKT.DE) */ 00719 double de_ae_max; 00720 /* largest absolute error */ 00721 int de_ae_col; 00722 /* number of column with largest absolute error */ 00723 double de_re_max; 00724 /* largest relative error */ 00725 int de_re_col; 00726 /* number of column with largest relative error */ 00727 int de_quality; 00728 /* quality of dual solution: 00729 'H' - high 00730 'M' - medium 00731 'L' - low 00732 '?' - dual solution is wrong */ 00733 /*--------------------------------------------------------------*/ 00734 /* d[k] >= 0 or d[k] <= 0 (KKT.DB) */ 00735 double db_ae_max; 00736 /* largest absolute error */ 00737 int db_ae_ind; 00738 /* number of variable with largest absolute error */ 00739 double db_re_max; 00740 /* largest relative error */ 00741 int db_re_ind; 00742 /* number of variable with largest relative error */ 00743 int db_quality; 00744 /* quality of dual feasibility: 00745 'H' - high 00746 'M' - medium 00747 'L' - low 00748 '?' - dual solution is infeasible */ 00749 /*--------------------------------------------------------------*/ 00750 /* (x[k] - bound of x[k]) * d[k] = 0 (KKT.CS) */ 00751 double cs_ae_max; 00752 /* largest absolute error */ 00753 int cs_ae_ind; 00754 /* number of variable with largest absolute error */ 00755 double cs_re_max; 00756 /* largest relative error */ 00757 int cs_re_ind; 00758 /* number of variable with largest relative error */ 00759 int cs_quality; 00760 /* quality of complementary slackness: 00761 'H' - high 00762 'M' - medium 00763 'L' - low 00764 '?' - primal and dual solutions are not complementary */ 00765 } LPXKKT; 00766 00767 #define lpx_create_prob _glp_lpx_create_prob 00768 LPX *lpx_create_prob(void); 00769 /* create problem object */ 00770 00771 #define lpx_set_prob_name _glp_lpx_set_prob_name 00772 void lpx_set_prob_name(LPX *lp, const char *name); 00773 /* assign (change) problem name */ 00774 00775 #define lpx_set_obj_name _glp_lpx_set_obj_name 00776 void lpx_set_obj_name(LPX *lp, const char *name); 00777 /* assign (change) objective function name */ 00778 00779 #define lpx_set_obj_dir _glp_lpx_set_obj_dir 00780 void lpx_set_obj_dir(LPX *lp, int dir); 00781 /* set (change) optimization direction flag */ 00782 00783 #define lpx_add_rows _glp_lpx_add_rows 00784 int lpx_add_rows(LPX *lp, int nrs); 00785 /* add new rows to problem object */ 00786 00787 #define lpx_add_cols _glp_lpx_add_cols 00788 int lpx_add_cols(LPX *lp, int ncs); 00789 /* add new columns to problem object */ 00790 00791 #define lpx_set_row_name _glp_lpx_set_row_name 00792 void lpx_set_row_name(LPX *lp, int i, const char *name); 00793 /* assign (change) row name */ 00794 00795 #define lpx_set_col_name _glp_lpx_set_col_name 00796 void lpx_set_col_name(LPX *lp, int j, const char *name); 00797 /* assign (change) column name */ 00798 00799 #define lpx_set_row_bnds _glp_lpx_set_row_bnds 00800 void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub); 00801 /* set (change) row bounds */ 00802 00803 #define lpx_set_col_bnds _glp_lpx_set_col_bnds 00804 void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub); 00805 /* set (change) column bounds */ 00806 00807 #define lpx_set_obj_coef _glp_lpx_set_obj_coef 00808 void lpx_set_obj_coef(glp_prob *lp, int j, double coef); 00809 /* set (change) obj. coefficient or constant term */ 00810 00811 #define lpx_set_mat_row _glp_lpx_set_mat_row 00812 void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[], 00813 const double val[]); 00814 /* set (replace) row of the constraint matrix */ 00815 00816 #define lpx_set_mat_col _glp_lpx_set_mat_col 00817 void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[], 00818 const double val[]); 00819 /* set (replace) column of the constraint matrix */ 00820 00821 #define lpx_load_matrix _glp_lpx_load_matrix 00822 void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[], 00823 const double ar[]); 00824 /* load (replace) the whole constraint matrix */ 00825 00826 #define lpx_del_rows _glp_lpx_del_rows 00827 void lpx_del_rows(LPX *lp, int nrs, const int num[]); 00828 /* delete specified rows from problem object */ 00829 00830 #define lpx_del_cols _glp_lpx_del_cols 00831 void lpx_del_cols(LPX *lp, int ncs, const int num[]); 00832 /* delete specified columns from problem object */ 00833 00834 #define lpx_delete_prob _glp_lpx_delete_prob 00835 void lpx_delete_prob(LPX *lp); 00836 /* delete problem object */ 00837 00838 #define lpx_get_prob_name _glp_lpx_get_prob_name 00839 const char *lpx_get_prob_name(LPX *lp); 00840 /* retrieve problem name */ 00841 00842 #define lpx_get_obj_name _glp_lpx_get_obj_name 00843 const char *lpx_get_obj_name(LPX *lp); 00844 /* retrieve objective function name */ 00845 00846 #define lpx_get_obj_dir _glp_lpx_get_obj_dir 00847 int lpx_get_obj_dir(LPX *lp); 00848 /* retrieve optimization direction flag */ 00849 00850 #define lpx_get_num_rows _glp_lpx_get_num_rows 00851 int lpx_get_num_rows(LPX *lp); 00852 /* retrieve number of rows */ 00853 00854 #define lpx_get_num_cols _glp_lpx_get_num_cols 00855 int lpx_get_num_cols(LPX *lp); 00856 /* retrieve number of columns */ 00857 00858 #define lpx_get_row_name _glp_lpx_get_row_name 00859 const char *lpx_get_row_name(LPX *lp, int i); 00860 /* retrieve row name */ 00861 00862 #define lpx_get_col_name _glp_lpx_get_col_name 00863 const char *lpx_get_col_name(LPX *lp, int j); 00864 /* retrieve column name */ 00865 00866 #define lpx_get_row_type _glp_lpx_get_row_type 00867 int lpx_get_row_type(LPX *lp, int i); 00868 /* retrieve row type */ 00869 00870 #define lpx_get_row_lb _glp_lpx_get_row_lb 00871 double lpx_get_row_lb(LPX *lp, int i); 00872 /* retrieve row lower bound */ 00873 00874 #define lpx_get_row_ub _glp_lpx_get_row_ub 00875 double lpx_get_row_ub(LPX *lp, int i); 00876 /* retrieve row upper bound */ 00877 00878 #define lpx_get_row_bnds _glp_lpx_get_row_bnds 00879 void lpx_get_row_bnds(LPX *lp, int i, int *typx, double *lb, 00880 double *ub); 00881 /* retrieve row bounds */ 00882 00883 #define lpx_get_col_type _glp_lpx_get_col_type 00884 int lpx_get_col_type(LPX *lp, int j); 00885 /* retrieve column type */ 00886 00887 #define lpx_get_col_lb _glp_lpx_get_col_lb 00888 double lpx_get_col_lb(LPX *lp, int j); 00889 /* retrieve column lower bound */ 00890 00891 #define lpx_get_col_ub _glp_lpx_get_col_ub 00892 double lpx_get_col_ub(LPX *lp, int j); 00893 /* retrieve column upper bound */ 00894 00895 #define lpx_get_col_bnds _glp_lpx_get_col_bnds 00896 void lpx_get_col_bnds(LPX *lp, int j, int *typx, double *lb, 00897 double *ub); 00898 /* retrieve column bounds */ 00899 00900 #define lpx_get_obj_coef _glp_lpx_get_obj_coef 00901 double lpx_get_obj_coef(LPX *lp, int j); 00902 /* retrieve obj. coefficient or constant term */ 00903 00904 #define lpx_get_num_nz _glp_lpx_get_num_nz 00905 int lpx_get_num_nz(LPX *lp); 00906 /* retrieve number of constraint coefficients */ 00907 00908 #define lpx_get_mat_row _glp_lpx_get_mat_row 00909 int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[]); 00910 /* retrieve row of the constraint matrix */ 00911 00912 #define lpx_get_mat_col _glp_lpx_get_mat_col 00913 int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[]); 00914 /* retrieve column of the constraint matrix */ 00915 00916 #define lpx_create_index _glp_lpx_create_index 00917 void lpx_create_index(LPX *lp); 00918 /* create the name index */ 00919 00920 #define lpx_find_row _glp_lpx_find_row 00921 int lpx_find_row(LPX *lp, const char *name); 00922 /* find row by its name */ 00923 00924 #define lpx_find_col _glp_lpx_find_col 00925 int lpx_find_col(LPX *lp, const char *name); 00926 /* find column by its name */ 00927 00928 #define lpx_delete_index _glp_lpx_delete_index 00929 void lpx_delete_index(LPX *lp); 00930 /* delete the name index */ 00931 00932 #define lpx_scale_prob _glp_lpx_scale_prob 00933 void lpx_scale_prob(LPX *lp); 00934 /* scale problem data */ 00935 00936 #define lpx_unscale_prob _glp_lpx_unscale_prob 00937 void lpx_unscale_prob(LPX *lp); 00938 /* unscale problem data */ 00939 00940 #define lpx_std_basis _glp_lpx_std_basis 00941 void lpx_std_basis(LPX *lp); 00942 /* construct standard initial LP basis */ 00943 00944 #define lpx_adv_basis _glp_lpx_adv_basis 00945 void lpx_adv_basis(LPX *lp); 00946 /* construct advanced initial LP basis */ 00947 00948 #define lpx_cpx_basis _glp_lpx_cpx_basis 00949 void lpx_cpx_basis(LPX *lp); 00950 /* construct Bixby's initial LP basis */ 00951 00952 #define lpx_set_row_stat _glp_lpx_set_row_stat 00953 void lpx_set_row_stat(LPX *lp, int i, int stat); 00954 /* set (change) row status */ 00955 00956 #define lpx_set_col_stat _glp_lpx_set_col_stat 00957 void lpx_set_col_stat(LPX *lp, int j, int stat); 00958 /* set (change) column status */ 00959 00960 #define lpx_simplex _glp_lpx_simplex 00961 int lpx_simplex(LPX *lp); 00962 /* easy-to-use driver to the simplex method */ 00963 00964 #define lpx_exact _glp_lpx_exact 00965 int lpx_exact(LPX *lp); 00966 /* easy-to-use driver to the exact simplex method */ 00967 00968 #define lpx_get_status _glp_lpx_get_status 00969 int lpx_get_status(LPX *lp); 00970 /* retrieve generic status of basic solution */ 00971 00972 #define lpx_get_prim_stat _glp_lpx_get_prim_stat 00973 int lpx_get_prim_stat(LPX *lp); 00974 /* retrieve primal status of basic solution */ 00975 00976 #define lpx_get_dual_stat _glp_lpx_get_dual_stat 00977 int lpx_get_dual_stat(LPX *lp); 00978 /* retrieve dual status of basic solution */ 00979 00980 #define lpx_get_obj_val _glp_lpx_get_obj_val 00981 double lpx_get_obj_val(LPX *lp); 00982 /* retrieve objective value (basic solution) */ 00983 00984 #define lpx_get_row_stat _glp_lpx_get_row_stat 00985 int lpx_get_row_stat(LPX *lp, int i); 00986 /* retrieve row status (basic solution) */ 00987 00988 #define lpx_get_row_prim _glp_lpx_get_row_prim 00989 double lpx_get_row_prim(LPX *lp, int i); 00990 /* retrieve row primal value (basic solution) */ 00991 00992 #define lpx_get_row_dual _glp_lpx_get_row_dual 00993 double lpx_get_row_dual(LPX *lp, int i); 00994 /* retrieve row dual value (basic solution) */ 00995 00996 #define lpx_get_row_info _glp_lpx_get_row_info 00997 void lpx_get_row_info(LPX *lp, int i, int *tagx, double *vx, 00998 double *dx); 00999 /* obtain row solution information */ 01000 01001 #define lpx_get_col_stat _glp_lpx_get_col_stat 01002 int lpx_get_col_stat(LPX *lp, int j); 01003 /* retrieve column status (basic solution) */ 01004 01005 #define lpx_get_col_prim _glp_lpx_get_col_prim 01006 double lpx_get_col_prim(LPX *lp, int j); 01007 /* retrieve column primal value (basic solution) */ 01008 01009 #define lpx_get_col_dual _glp_lpx_get_col_dual 01010 double lpx_get_col_dual(glp_prob *lp, int j); 01011 /* retrieve column dual value (basic solution) */ 01012 01013 #define lpx_get_col_info _glp_lpx_get_col_info 01014 void lpx_get_col_info(LPX *lp, int j, int *tagx, double *vx, 01015 double *dx); 01016 /* obtain column solution information (obsolete) */ 01017 01018 #define lpx_get_ray_info _glp_lpx_get_ray_info 01019 int lpx_get_ray_info(LPX *lp); 01020 /* determine what causes primal unboundness */ 01021 01022 #define lpx_check_kkt _glp_lpx_check_kkt 01023 void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt); 01024 /* check Karush-Kuhn-Tucker conditions */ 01025 01026 #define lpx_warm_up _glp_lpx_warm_up 01027 int lpx_warm_up(LPX *lp); 01028 /* "warm up" LP basis */ 01029 01030 #define lpx_eval_tab_row _glp_lpx_eval_tab_row 01031 int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[]); 01032 /* compute row of the simplex table */ 01033 01034 #define lpx_eval_tab_col _glp_lpx_eval_tab_col 01035 int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[]); 01036 /* compute column of the simplex table */ 01037 01038 #define lpx_transform_row _glp_lpx_transform_row 01039 int lpx_transform_row(LPX *lp, int len, int ind[], double val[]); 01040 /* transform explicitly specified row */ 01041 01042 #define lpx_transform_col _glp_lpx_transform_col 01043 int lpx_transform_col(LPX *lp, int len, int ind[], double val[]); 01044 /* transform explicitly specified column */ 01045 01046 #define lpx_prim_ratio_test _glp_lpx_prim_ratio_test 01047 int lpx_prim_ratio_test(LPX *lp, int len, const int ind[], 01048 const double val[], int how, double tol); 01049 /* perform primal ratio test */ 01050 01051 #define lpx_dual_ratio_test _glp_lpx_dual_ratio_test 01052 int lpx_dual_ratio_test(LPX *lp, int len, const int ind[], 01053 const double val[], int how, double tol); 01054 /* perform dual ratio test */ 01055 01056 #define lpx_interior _glp_lpx_interior 01057 int lpx_interior(LPX *lp); 01058 /* easy-to-use driver to the interior point method */ 01059 01060 #define lpx_ipt_status _glp_lpx_ipt_status 01061 int lpx_ipt_status(LPX *lp); 01062 /* retrieve status of interior-point solution */ 01063 01064 #define lpx_ipt_obj_val _glp_lpx_ipt_obj_val 01065 double lpx_ipt_obj_val(LPX *lp); 01066 /* retrieve objective value (interior point) */ 01067 01068 #define lpx_ipt_row_prim _glp_lpx_ipt_row_prim 01069 double lpx_ipt_row_prim(LPX *lp, int i); 01070 /* retrieve row primal value (interior point) */ 01071 01072 #define lpx_ipt_row_dual _glp_lpx_ipt_row_dual 01073 double lpx_ipt_row_dual(LPX *lp, int i); 01074 /* retrieve row dual value (interior point) */ 01075 01076 #define lpx_ipt_col_prim _glp_lpx_ipt_col_prim 01077 double lpx_ipt_col_prim(LPX *lp, int j); 01078 /* retrieve column primal value (interior point) */ 01079 01080 #define lpx_ipt_col_dual _glp_lpx_ipt_col_dual 01081 double lpx_ipt_col_dual(LPX *lp, int j); 01082 /* retrieve column dual value (interior point) */ 01083 01084 #define lpx_set_class _glp_lpx_set_class 01085 void lpx_set_class(LPX *lp, int klass); 01086 /* set problem class */ 01087 01088 #define lpx_get_class _glp_lpx_get_class 01089 int lpx_get_class(LPX *lp); 01090 /* determine problem klass */ 01091 01092 #define lpx_set_col_kind _glp_lpx_set_col_kind 01093 void lpx_set_col_kind(LPX *lp, int j, int kind); 01094 /* set (change) column kind */ 01095 01096 #define lpx_get_col_kind _glp_lpx_get_col_kind 01097 int lpx_get_col_kind(LPX *lp, int j); 01098 /* retrieve column kind */ 01099 01100 #define lpx_get_num_int _glp_lpx_get_num_int 01101 int lpx_get_num_int(LPX *lp); 01102 /* retrieve number of integer columns */ 01103 01104 #define lpx_get_num_bin _glp_lpx_get_num_bin 01105 int lpx_get_num_bin(LPX *lp); 01106 /* retrieve number of binary columns */ 01107 01108 #define lpx_integer _glp_lpx_integer 01109 int lpx_integer(LPX *lp); 01110 /* easy-to-use driver to the branch-and-bound method */ 01111 01112 #define lpx_intopt _glp_lpx_intopt 01113 int lpx_intopt(LPX *mip); 01114 /* easy-to-use driver to the branch-and-bound method */ 01115 01116 #define lpx_mip_status _glp_lpx_mip_status 01117 int lpx_mip_status(LPX *lp); 01118 /* retrieve status of MIP solution */ 01119 01120 #define lpx_mip_obj_val _glp_lpx_mip_obj_val 01121 double lpx_mip_obj_val(LPX *lp); 01122 /* retrieve objective value (MIP solution) */ 01123 01124 #define lpx_mip_row_val _glp_lpx_mip_row_val 01125 double lpx_mip_row_val(LPX *lp, int i); 01126 /* retrieve row value (MIP solution) */ 01127 01128 #define lpx_mip_col_val _glp_lpx_mip_col_val 01129 double lpx_mip_col_val(LPX *lp, int j); 01130 /* retrieve column value (MIP solution) */ 01131 01132 #define lpx_check_int _glp_lpx_check_int 01133 void lpx_check_int(LPX *lp, LPXKKT *kkt); 01134 /* check integer feasibility conditions */ 01135 01136 #define lpx_reset_parms _glp_lpx_reset_parms 01137 void lpx_reset_parms(LPX *lp); 01138 /* reset control parameters to default values */ 01139 01140 #define lpx_set_int_parm _glp_lpx_set_int_parm 01141 void lpx_set_int_parm(LPX *lp, int parm, int val); 01142 /* set (change) integer control parameter */ 01143 01144 #define lpx_get_int_parm _glp_lpx_get_int_parm 01145 int lpx_get_int_parm(LPX *lp, int parm); 01146 /* query integer control parameter */ 01147 01148 #define lpx_set_real_parm _glp_lpx_set_real_parm 01149 void lpx_set_real_parm(LPX *lp, int parm, double val); 01150 /* set (change) real control parameter */ 01151 01152 #define lpx_get_real_parm _glp_lpx_get_real_parm 01153 double lpx_get_real_parm(LPX *lp, int parm); 01154 /* query real control parameter */ 01155 01156 #define lpx_read_mps _glp_lpx_read_mps 01157 LPX *lpx_read_mps(const char *fname); 01158 /* read problem data in fixed MPS format */ 01159 01160 #define lpx_write_mps _glp_lpx_write_mps 01161 int lpx_write_mps(LPX *lp, const char *fname); 01162 /* write problem data in fixed MPS format */ 01163 01164 #define lpx_read_bas _glp_lpx_read_bas 01165 int lpx_read_bas(LPX *lp, const char *fname); 01166 /* read LP basis in fixed MPS format */ 01167 01168 #define lpx_write_bas _glp_lpx_write_bas 01169 int lpx_write_bas(LPX *lp, const char *fname); 01170 /* write LP basis in fixed MPS format */ 01171 01172 #define lpx_read_freemps _glp_lpx_read_freemps 01173 LPX *lpx_read_freemps(const char *fname); 01174 /* read problem data in free MPS format */ 01175 01176 #define lpx_write_freemps _glp_lpx_write_freemps 01177 int lpx_write_freemps(LPX *lp, const char *fname); 01178 /* write problem data in free MPS format */ 01179 01180 #define lpx_read_cpxlp _glp_lpx_read_cpxlp 01181 LPX *lpx_read_cpxlp(const char *fname); 01182 /* read problem data in CPLEX LP format */ 01183 01184 #define lpx_write_cpxlp _glp_lpx_write_cpxlp 01185 int lpx_write_cpxlp(LPX *lp, const char *fname); 01186 /* write problem data in CPLEX LP format */ 01187 01188 #define lpx_read_model _glp_lpx_read_model 01189 LPX *lpx_read_model(const char *model, const char *data, 01190 const char *output); 01191 /* read LP/MIP model written in GNU MathProg language */ 01192 01193 #define lpx_print_prob _glp_lpx_print_prob 01194 int lpx_print_prob(LPX *lp, const char *fname); 01195 /* write problem data in plain text format */ 01196 01197 #define lpx_print_sol _glp_lpx_print_sol 01198 int lpx_print_sol(LPX *lp, const char *fname); 01199 /* write LP problem solution in printable format */ 01200 01201 #define lpx_print_sens_bnds _glp_lpx_print_sens_bnds 01202 int lpx_print_sens_bnds(LPX *lp, const char *fname); 01203 /* write bounds sensitivity information */ 01204 01205 #define lpx_print_ips _glp_lpx_print_ips 01206 int lpx_print_ips(LPX *lp, const char *fname); 01207 /* write interior point solution in printable format */ 01208 01209 #define lpx_print_mip _glp_lpx_print_mip 01210 int lpx_print_mip(LPX *lp, const char *fname); 01211 /* write MIP problem solution in printable format */ 01212 01213 #define lpx_is_b_avail _glp_lpx_is_b_avail 01214 int lpx_is_b_avail(LPX *lp); 01215 /* check if LP basis is available */ 01216 01217 #define lpx_write_pb _glp_lpx_write_pb 01218 int lpx_write_pb(LPX *lp, const char *fname, int normalized); 01219 /* write problem data in (normalized) OPB format */ 01220 01221 #define lpx_main _glp_lpx_main 01222 int lpx_main(int argc, const char *argv[]); 01223 /* stand-alone LP/MIP solver */ 01224 01225 #ifdef __cplusplus 01226 } 01227 #endif 01228 01229 #endif 01230 01231 /* eof */