alpar@9: /* glplpx01.c (obsolete API routines) */
alpar@9: 
alpar@9: /***********************************************************************
alpar@9: *  This code is part of GLPK (GNU Linear Programming Kit).
alpar@9: *
alpar@9: *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
alpar@9: *  2009, 2010, 2011 Andrew Makhorin, Department for Applied Informatics,
alpar@9: *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.
alpar@9: *  E-mail: <mao@gnu.org>.
alpar@9: *
alpar@9: *  GLPK is free software: you can redistribute it and/or modify it
alpar@9: *  under the terms of the GNU General Public License as published by
alpar@9: *  the Free Software Foundation, either version 3 of the License, or
alpar@9: *  (at your option) any later version.
alpar@9: *
alpar@9: *  GLPK is distributed in the hope that it will be useful, but WITHOUT
alpar@9: *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
alpar@9: *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
alpar@9: *  License for more details.
alpar@9: *
alpar@9: *  You should have received a copy of the GNU General Public License
alpar@9: *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.
alpar@9: ***********************************************************************/
alpar@9: 
alpar@9: #include "glpapi.h"
alpar@9: 
alpar@9: struct LPXCPS
alpar@9: {     /* control parameters and statistics */
alpar@9:       int msg_lev;
alpar@9:       /* level of messages output by the solver:
alpar@9:          0 - no output
alpar@9:          1 - error messages only
alpar@9:          2 - normal output
alpar@9:          3 - full output (includes informational messages) */
alpar@9:       int scale;
alpar@9:       /* scaling option:
alpar@9:          0 - no scaling
alpar@9:          1 - equilibration scaling
alpar@9:          2 - geometric mean scaling
alpar@9:          3 - geometric mean scaling, then equilibration scaling */
alpar@9:       int dual;
alpar@9:       /* dual simplex option:
alpar@9:          0 - use primal simplex
alpar@9:          1 - use dual simplex */
alpar@9:       int price;
alpar@9:       /* pricing option (for both primal and dual simplex):
alpar@9:          0 - textbook pricing
alpar@9:          1 - steepest edge pricing */
alpar@9:       double relax;
alpar@9:       /* relaxation parameter used in the ratio test; if it is zero,
alpar@9:          the textbook ratio test is used; if it is non-zero (should be
alpar@9:          positive), Harris' two-pass ratio test is used; in the latter
alpar@9:          case on the first pass basic variables (in the case of primal
alpar@9:          simplex) or reduced costs of non-basic variables (in the case
alpar@9:          of dual simplex) are allowed to slightly violate their bounds,
alpar@9:          but not more than (relax * tol_bnd) or (relax * tol_dj) (thus,
alpar@9:          relax is a percentage of tol_bnd or tol_dj) */
alpar@9:       double tol_bnd;
alpar@9:       /* relative tolerance used to check if the current basic solution
alpar@9:          is primal feasible */
alpar@9:       double tol_dj;
alpar@9:       /* absolute tolerance used to check if the current basic solution
alpar@9:          is dual feasible */
alpar@9:       double tol_piv;
alpar@9:       /* relative tolerance used to choose eligible pivotal elements of
alpar@9:          the simplex table in the ratio test */
alpar@9:       int round;
alpar@9:       /* solution rounding option:
alpar@9:          0 - report all computed values and reduced costs "as is"
alpar@9:          1 - if possible (allowed by the tolerances), replace computed
alpar@9:              values and reduced costs which are close to zero by exact
alpar@9:              zeros */
alpar@9:       double obj_ll;
alpar@9:       /* lower limit of the objective function; if on the phase II the
alpar@9:          objective function reaches this limit and continues decreasing,
alpar@9:          the solver stops the search */
alpar@9:       double obj_ul;
alpar@9:       /* upper limit of the objective function; if on the phase II the
alpar@9:          objective function reaches this limit and continues increasing,
alpar@9:          the solver stops the search */
alpar@9:       int it_lim;
alpar@9:       /* simplex iterations limit; if this value is positive, it is
alpar@9:          decreased by one each time when one simplex iteration has been
alpar@9:          performed, and reaching zero value signals the solver to stop
alpar@9:          the search; negative value means no iterations limit */
alpar@9:       double tm_lim;
alpar@9:       /* searching time limit, in seconds; if this value is positive,
alpar@9:          it is decreased each time when one simplex iteration has been
alpar@9:          performed by the amount of time spent for the iteration, and
alpar@9:          reaching zero value signals the solver to stop the search;
alpar@9:          negative value means no time limit */
alpar@9:       int out_frq;
alpar@9:       /* output frequency, in iterations; this parameter specifies how
alpar@9:          frequently the solver sends information about the solution to
alpar@9:          the standard output */
alpar@9:       double out_dly;
alpar@9:       /* output delay, in seconds; this parameter specifies how long
alpar@9:          the solver should delay sending information about the solution
alpar@9:          to the standard output; zero value means no delay */
alpar@9:       int branch; /* MIP */
alpar@9:       /* branching heuristic:
alpar@9:          0 - branch on first variable
alpar@9:          1 - branch on last variable
alpar@9:          2 - branch using heuristic by Driebeck and Tomlin
alpar@9:          3 - branch on most fractional variable */
alpar@9:       int btrack; /* MIP */
alpar@9:       /* backtracking heuristic:
alpar@9:          0 - select most recent node (depth first search)
alpar@9:          1 - select earliest node (breadth first search)
alpar@9:          2 - select node using the best projection heuristic
alpar@9:          3 - select node with best local bound */
alpar@9:       double tol_int; /* MIP */
alpar@9:       /* absolute tolerance used to check if the current basic solution
alpar@9:          is integer feasible */
alpar@9:       double tol_obj; /* MIP */
alpar@9:       /* relative tolerance used to check if the value of the objective
alpar@9:          function is not better than in the best known integer feasible
alpar@9:          solution */
alpar@9:       int mps_info; /* lpx_write_mps */
alpar@9:       /* if this flag is set, the routine lpx_write_mps outputs several
alpar@9:          comment cards that contains some information about the problem;
alpar@9:          otherwise the routine outputs no comment cards */
alpar@9:       int mps_obj; /* lpx_write_mps */
alpar@9:       /* this parameter tells the routine lpx_write_mps how to output
alpar@9:          the objective function row:
alpar@9:          0 - never output objective function row
alpar@9:          1 - always output objective function row
alpar@9:          2 - output objective function row if and only if the problem
alpar@9:              has no free rows */
alpar@9:       int mps_orig; /* lpx_write_mps */
alpar@9:       /* if this flag is set, the routine lpx_write_mps uses original
alpar@9:          row and column symbolic names; otherwise the routine generates
alpar@9:          plain names using ordinal numbers of rows and columns */
alpar@9:       int mps_wide; /* lpx_write_mps */
alpar@9:       /* if this flag is set, the routine lpx_write_mps uses all data
alpar@9:          fields; otherwise the routine keeps fields 5 and 6 empty */
alpar@9:       int mps_free; /* lpx_write_mps */
alpar@9:       /* if this flag is set, the routine lpx_write_mps omits column
alpar@9:          and vector names everytime if possible (free style); otherwise
alpar@9:          the routine never omits these names (pedantic style) */
alpar@9:       int mps_skip; /* lpx_write_mps */
alpar@9:       /* if this flag is set, the routine lpx_write_mps skips empty
alpar@9:          columns (i.e. which has no constraint coefficients); otherwise
alpar@9:          the routine outputs all columns */
alpar@9:       int lpt_orig; /* lpx_write_lpt */
alpar@9:       /* if this flag is set, the routine lpx_write_lpt uses original
alpar@9:          row and column symbolic names; otherwise the routine generates
alpar@9:          plain names using ordinal numbers of rows and columns */
alpar@9:       int presol; /* lpx_simplex */
alpar@9:       /* LP presolver option:
alpar@9:          0 - do not use LP presolver
alpar@9:          1 - use LP presolver */
alpar@9:       int binarize; /* lpx_intopt */
alpar@9:       /* if this flag is set, the routine lpx_intopt replaces integer
alpar@9:          columns by binary ones */
alpar@9:       int use_cuts; /* lpx_intopt */
alpar@9:       /* if this flag is set, the routine lpx_intopt tries generating
alpar@9:          cutting planes:
alpar@9:          LPX_C_COVER  - mixed cover cuts
alpar@9:          LPX_C_CLIQUE - clique cuts
alpar@9:          LPX_C_GOMORY - Gomory's mixed integer cuts
alpar@9:          LPX_C_ALL    - all cuts */
alpar@9:       double mip_gap; /* MIP */
alpar@9:       /* relative MIP gap tolerance */
alpar@9: };
alpar@9: 
alpar@9: LPX *lpx_create_prob(void)
alpar@9: {     /* create problem object */
alpar@9:       return glp_create_prob();
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_prob_name(LPX *lp, const char *name)
alpar@9: {     /* assign (change) problem name */
alpar@9:       glp_set_prob_name(lp, name);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_obj_name(LPX *lp, const char *name)
alpar@9: {     /* assign (change) objective function name */
alpar@9:       glp_set_obj_name(lp, name);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_obj_dir(LPX *lp, int dir)
alpar@9: {     /* set (change) optimization direction flag */
alpar@9:       glp_set_obj_dir(lp, dir - LPX_MIN + GLP_MIN);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_add_rows(LPX *lp, int nrs)
alpar@9: {     /* add new rows to problem object */
alpar@9:       return glp_add_rows(lp, nrs);
alpar@9: }
alpar@9: 
alpar@9: int lpx_add_cols(LPX *lp, int ncs)
alpar@9: {     /* add new columns to problem object */
alpar@9:       return glp_add_cols(lp, ncs);
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_row_name(LPX *lp, int i, const char *name)
alpar@9: {     /* assign (change) row name */
alpar@9:       glp_set_row_name(lp, i, name);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_col_name(LPX *lp, int j, const char *name)
alpar@9: {     /* assign (change) column name */
alpar@9:       glp_set_col_name(lp, j, name);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub)
alpar@9: {     /* set (change) row bounds */
alpar@9:       glp_set_row_bnds(lp, i, type - LPX_FR + GLP_FR, lb, ub);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub)
alpar@9: {     /* set (change) column bounds */
alpar@9:       glp_set_col_bnds(lp, j, type - LPX_FR + GLP_FR, lb, ub);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_obj_coef(glp_prob *lp, int j, double coef)
alpar@9: {     /* set (change) obj. coefficient or constant term */
alpar@9:       glp_set_obj_coef(lp, j, coef);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
alpar@9:       const double val[])
alpar@9: {     /* set (replace) row of the constraint matrix */
alpar@9:       glp_set_mat_row(lp, i, len, ind, val);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
alpar@9:       const double val[])
alpar@9: {     /* set (replace) column of the constraint matrix */
alpar@9:       glp_set_mat_col(lp, j, len, ind, val);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
alpar@9:       const double ar[])
alpar@9: {     /* load (replace) the whole constraint matrix */
alpar@9:       glp_load_matrix(lp, ne, ia, ja, ar);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_del_rows(LPX *lp, int nrs, const int num[])
alpar@9: {     /* delete specified rows from problem object */
alpar@9:       glp_del_rows(lp, nrs, num);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_del_cols(LPX *lp, int ncs, const int num[])
alpar@9: {     /* delete specified columns from problem object */
alpar@9:       glp_del_cols(lp, ncs, num);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_delete_prob(LPX *lp)
alpar@9: {     /* delete problem object */
alpar@9:       glp_delete_prob(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: const char *lpx_get_prob_name(LPX *lp)
alpar@9: {     /* retrieve problem name */
alpar@9:       return glp_get_prob_name(lp);
alpar@9: }
alpar@9: 
alpar@9: const char *lpx_get_obj_name(LPX *lp)
alpar@9: {     /* retrieve objective function name */
alpar@9:       return glp_get_obj_name(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_obj_dir(LPX *lp)
alpar@9: {     /* retrieve optimization direction flag */
alpar@9:       return glp_get_obj_dir(lp) - GLP_MIN + LPX_MIN;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_num_rows(LPX *lp)
alpar@9: {     /* retrieve number of rows */
alpar@9:       return glp_get_num_rows(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_num_cols(LPX *lp)
alpar@9: {     /* retrieve number of columns */
alpar@9:       return glp_get_num_cols(lp);
alpar@9: }
alpar@9: 
alpar@9: const char *lpx_get_row_name(LPX *lp, int i)
alpar@9: {     /* retrieve row name */
alpar@9:       return glp_get_row_name(lp, i);
alpar@9: }
alpar@9: 
alpar@9: const char *lpx_get_col_name(LPX *lp, int j)
alpar@9: {     /* retrieve column name */
alpar@9:       return glp_get_col_name(lp, j);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_row_type(LPX *lp, int i)
alpar@9: {     /* retrieve row type */
alpar@9:       return glp_get_row_type(lp, i) - GLP_FR + LPX_FR;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_row_lb(glp_prob *lp, int i)
alpar@9: {     /* retrieve row lower bound */
alpar@9:       double lb;
alpar@9:       lb = glp_get_row_lb(lp, i);
alpar@9:       if (lb == -DBL_MAX) lb = 0.0;
alpar@9:       return lb;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_row_ub(glp_prob *lp, int i)
alpar@9: {     /* retrieve row upper bound */
alpar@9:       double ub;
alpar@9:       ub = glp_get_row_ub(lp, i);
alpar@9:       if (ub == +DBL_MAX) ub = 0.0;
alpar@9:       return ub;
alpar@9: }
alpar@9: 
alpar@9: void lpx_get_row_bnds(glp_prob *lp, int i, int *typx, double *lb,
alpar@9:       double *ub)
alpar@9: {     /* retrieve row bounds */
alpar@9:       if (typx != NULL) *typx = lpx_get_row_type(lp, i);
alpar@9:       if (lb != NULL) *lb = lpx_get_row_lb(lp, i);
alpar@9:       if (ub != NULL) *ub = lpx_get_row_ub(lp, i);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_col_type(LPX *lp, int j)
alpar@9: {     /* retrieve column type */
alpar@9:       return glp_get_col_type(lp, j) - GLP_FR + LPX_FR;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_col_lb(glp_prob *lp, int j)
alpar@9: {     /* retrieve column lower bound */
alpar@9:       double lb;
alpar@9:       lb = glp_get_col_lb(lp, j);
alpar@9:       if (lb == -DBL_MAX) lb = 0.0;
alpar@9:       return lb;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_col_ub(glp_prob *lp, int j)
alpar@9: {     /* retrieve column upper bound */
alpar@9:       double ub;
alpar@9:       ub = glp_get_col_ub(lp, j);
alpar@9:       if (ub == +DBL_MAX) ub = 0.0;
alpar@9:       return ub;
alpar@9: }
alpar@9: 
alpar@9: void lpx_get_col_bnds(glp_prob *lp, int j, int *typx, double *lb,
alpar@9:       double *ub)
alpar@9: {     /* retrieve column bounds */
alpar@9:       if (typx != NULL) *typx = lpx_get_col_type(lp, j);
alpar@9:       if (lb != NULL) *lb = lpx_get_col_lb(lp, j);
alpar@9:       if (ub != NULL) *ub = lpx_get_col_ub(lp, j);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_obj_coef(LPX *lp, int j)
alpar@9: {     /* retrieve obj. coefficient or constant term */
alpar@9:       return glp_get_obj_coef(lp, j);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_num_nz(LPX *lp)
alpar@9: {     /* retrieve number of constraint coefficients */
alpar@9:       return glp_get_num_nz(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[])
alpar@9: {     /* retrieve row of the constraint matrix */
alpar@9:       return glp_get_mat_row(lp, i, ind, val);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[])
alpar@9: {     /* retrieve column of the constraint matrix */
alpar@9:       return glp_get_mat_col(lp, j, ind, val);
alpar@9: }
alpar@9: 
alpar@9: void lpx_create_index(LPX *lp)
alpar@9: {     /* create the name index */
alpar@9:       glp_create_index(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_find_row(LPX *lp, const char *name)
alpar@9: {     /* find row by its name */
alpar@9:       return glp_find_row(lp, name);
alpar@9: }
alpar@9: 
alpar@9: int lpx_find_col(LPX *lp, const char *name)
alpar@9: {     /* find column by its name */
alpar@9:       return glp_find_col(lp, name);
alpar@9: }
alpar@9: 
alpar@9: void lpx_delete_index(LPX *lp)
alpar@9: {     /* delete the name index */
alpar@9:       glp_delete_index(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_scale_prob(LPX *lp)
alpar@9: {     /* scale problem data */
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_SCALE))
alpar@9:       {  case 0:
alpar@9:             /* no scaling */
alpar@9:             glp_unscale_prob(lp);
alpar@9:             break;
alpar@9:          case 1:
alpar@9:             /* equilibration scaling */
alpar@9:             glp_scale_prob(lp, GLP_SF_EQ);
alpar@9:             break;
alpar@9:          case 2:
alpar@9:             /* geometric mean scaling */
alpar@9:             glp_scale_prob(lp, GLP_SF_GM);
alpar@9:             break;
alpar@9:          case 3:
alpar@9:             /* geometric mean scaling, then equilibration scaling */
alpar@9:             glp_scale_prob(lp, GLP_SF_GM | GLP_SF_EQ);
alpar@9:             break;
alpar@9:          default:
alpar@9:             xassert(lp != lp);
alpar@9:       }
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_unscale_prob(LPX *lp)
alpar@9: {     /* unscale problem data */
alpar@9:       glp_unscale_prob(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_row_stat(LPX *lp, int i, int stat)
alpar@9: {     /* set (change) row status */
alpar@9:       glp_set_row_stat(lp, i, stat - LPX_BS + GLP_BS);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_col_stat(LPX *lp, int j, int stat)
alpar@9: {     /* set (change) column status */
alpar@9:       glp_set_col_stat(lp, j, stat - LPX_BS + GLP_BS);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_std_basis(LPX *lp)
alpar@9: {     /* construct standard initial LP basis */
alpar@9:       glp_std_basis(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_adv_basis(LPX *lp)
alpar@9: {     /* construct advanced initial LP basis */
alpar@9:       glp_adv_basis(lp, 0);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: void lpx_cpx_basis(LPX *lp)
alpar@9: {     /* construct Bixby's initial LP basis */
alpar@9:       glp_cpx_basis(lp);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: static void fill_smcp(LPX *lp, glp_smcp *parm)
alpar@9: {     glp_init_smcp(parm);
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_MSGLEV))
alpar@9:       {  case 0:  parm->msg_lev = GLP_MSG_OFF;   break;
alpar@9:          case 1:  parm->msg_lev = GLP_MSG_ERR;   break;
alpar@9:          case 2:  parm->msg_lev = GLP_MSG_ON;    break;
alpar@9:          case 3:  parm->msg_lev = GLP_MSG_ALL;   break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_DUAL))
alpar@9:       {  case 0:  parm->meth = GLP_PRIMAL;       break;
alpar@9:          case 1:  parm->meth = GLP_DUAL;         break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_PRICE))
alpar@9:       {  case 0:  parm->pricing = GLP_PT_STD;    break;
alpar@9:          case 1:  parm->pricing = GLP_PT_PSE;    break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       if (lpx_get_real_parm(lp, LPX_K_RELAX) == 0.0)
alpar@9:          parm->r_test = GLP_RT_STD;
alpar@9:       else
alpar@9:          parm->r_test = GLP_RT_HAR;
alpar@9:       parm->tol_bnd = lpx_get_real_parm(lp, LPX_K_TOLBND);
alpar@9:       parm->tol_dj  = lpx_get_real_parm(lp, LPX_K_TOLDJ);
alpar@9:       parm->tol_piv = lpx_get_real_parm(lp, LPX_K_TOLPIV);
alpar@9:       parm->obj_ll  = lpx_get_real_parm(lp, LPX_K_OBJLL);
alpar@9:       parm->obj_ul  = lpx_get_real_parm(lp, LPX_K_OBJUL);
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_ITLIM) < 0)
alpar@9:          parm->it_lim = INT_MAX;
alpar@9:       else
alpar@9:          parm->it_lim = lpx_get_int_parm(lp, LPX_K_ITLIM);
alpar@9:       if (lpx_get_real_parm(lp, LPX_K_TMLIM) < 0.0)
alpar@9:          parm->tm_lim = INT_MAX;
alpar@9:       else
alpar@9:          parm->tm_lim =
alpar@9:             (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_TMLIM));
alpar@9:       parm->out_frq = lpx_get_int_parm(lp, LPX_K_OUTFRQ);
alpar@9:       parm->out_dly =
alpar@9:             (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_OUTDLY));
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_PRESOL))
alpar@9:       {  case 0:  parm->presolve = GLP_OFF;      break;
alpar@9:          case 1:  parm->presolve = GLP_ON;       break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_simplex(LPX *lp)
alpar@9: {     /* easy-to-use driver to the simplex method */
alpar@9:       glp_smcp parm;
alpar@9:       int ret;
alpar@9:       fill_smcp(lp, &parm);
alpar@9:       ret = glp_simplex(lp, &parm);
alpar@9:       switch (ret)
alpar@9:       {  case 0:           ret = LPX_E_OK;      break;
alpar@9:          case GLP_EBADB:
alpar@9:          case GLP_ESING:
alpar@9:          case GLP_ECOND:
alpar@9:          case GLP_EBOUND:  ret = LPX_E_FAULT;   break;
alpar@9:          case GLP_EFAIL:   ret = LPX_E_SING;    break;
alpar@9:          case GLP_EOBJLL:  ret = LPX_E_OBJLL;   break;
alpar@9:          case GLP_EOBJUL:  ret = LPX_E_OBJUL;   break;
alpar@9:          case GLP_EITLIM:  ret = LPX_E_ITLIM;   break;
alpar@9:          case GLP_ETMLIM:  ret = LPX_E_TMLIM;   break;
alpar@9:          case GLP_ENOPFS:  ret = LPX_E_NOPFS;   break;
alpar@9:          case GLP_ENODFS:  ret = LPX_E_NODFS;   break;
alpar@9:          default:          xassert(ret != ret);
alpar@9:       }
alpar@9:       return ret;
alpar@9: }
alpar@9: 
alpar@9: int lpx_exact(LPX *lp)
alpar@9: {     /* easy-to-use driver to the exact simplex method */
alpar@9:       glp_smcp parm;
alpar@9:       int ret;
alpar@9:       fill_smcp(lp, &parm);
alpar@9:       ret = glp_exact(lp, &parm);
alpar@9:       switch (ret)
alpar@9:       {  case 0:           ret = LPX_E_OK;      break;
alpar@9:          case GLP_EBADB:
alpar@9:          case GLP_ESING:
alpar@9:          case GLP_EBOUND:
alpar@9:          case GLP_EFAIL:   ret = LPX_E_FAULT;   break;
alpar@9:          case GLP_EITLIM:  ret = LPX_E_ITLIM;   break;
alpar@9:          case GLP_ETMLIM:  ret = LPX_E_TMLIM;   break;
alpar@9:          default:          xassert(ret != ret);
alpar@9:       }
alpar@9:       return ret;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_status(glp_prob *lp)
alpar@9: {     /* retrieve generic status of basic solution */
alpar@9:       int status;
alpar@9:       switch (glp_get_status(lp))
alpar@9:       {  case GLP_OPT:    status = LPX_OPT;    break;
alpar@9:          case GLP_FEAS:   status = LPX_FEAS;   break;
alpar@9:          case GLP_INFEAS: status = LPX_INFEAS; break;
alpar@9:          case GLP_NOFEAS: status = LPX_NOFEAS; break;
alpar@9:          case GLP_UNBND:  status = LPX_UNBND;  break;
alpar@9:          case GLP_UNDEF:  status = LPX_UNDEF;  break;
alpar@9:          default:         xassert(lp != lp);
alpar@9:       }
alpar@9:       return status;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_prim_stat(glp_prob *lp)
alpar@9: {     /* retrieve status of primal basic solution */
alpar@9:       return glp_get_prim_stat(lp) - GLP_UNDEF + LPX_P_UNDEF;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_dual_stat(glp_prob *lp)
alpar@9: {     /* retrieve status of dual basic solution */
alpar@9:       return glp_get_dual_stat(lp) - GLP_UNDEF + LPX_D_UNDEF;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_obj_val(LPX *lp)
alpar@9: {     /* retrieve objective value (basic solution) */
alpar@9:       return glp_get_obj_val(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_row_stat(LPX *lp, int i)
alpar@9: {     /* retrieve row status (basic solution) */
alpar@9:       return glp_get_row_stat(lp, i) - GLP_BS + LPX_BS;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_row_prim(LPX *lp, int i)
alpar@9: {     /* retrieve row primal value (basic solution) */
alpar@9:       return glp_get_row_prim(lp, i);
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_row_dual(LPX *lp, int i)
alpar@9: {     /* retrieve row dual value (basic solution) */
alpar@9:       return glp_get_row_dual(lp, i);
alpar@9: }
alpar@9: 
alpar@9: void lpx_get_row_info(glp_prob *lp, int i, int *tagx, double *vx,
alpar@9:       double *dx)
alpar@9: {     /* obtain row solution information */
alpar@9:       if (tagx != NULL) *tagx = lpx_get_row_stat(lp, i);
alpar@9:       if (vx != NULL) *vx = lpx_get_row_prim(lp, i);
alpar@9:       if (dx != NULL) *dx = lpx_get_row_dual(lp, i);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_col_stat(LPX *lp, int j)
alpar@9: {     /* retrieve column status (basic solution) */
alpar@9:       return glp_get_col_stat(lp, j) - GLP_BS + LPX_BS;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_col_prim(LPX *lp, int j)
alpar@9: {     /* retrieve column primal value (basic solution) */
alpar@9:       return glp_get_col_prim(lp, j);
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_col_dual(glp_prob *lp, int j)
alpar@9: {     /* retrieve column dual value (basic solution) */
alpar@9:       return glp_get_col_dual(lp, j);
alpar@9: }
alpar@9: 
alpar@9: void lpx_get_col_info(glp_prob *lp, int j, int *tagx, double *vx,
alpar@9:       double *dx)
alpar@9: {     /* obtain column solution information */
alpar@9:       if (tagx != NULL) *tagx = lpx_get_col_stat(lp, j);
alpar@9:       if (vx != NULL) *vx = lpx_get_col_prim(lp, j);
alpar@9:       if (dx != NULL) *dx = lpx_get_col_dual(lp, j);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_ray_info(LPX *lp)
alpar@9: {     /* determine what causes primal unboundness */
alpar@9:       return glp_get_unbnd_ray(lp);
alpar@9: }
alpar@9: 
alpar@9: void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt)
alpar@9: {     /* check Karush-Kuhn-Tucker conditions */
alpar@9:       int ae_ind, re_ind;
alpar@9:       double ae_max, re_max;
alpar@9:       xassert(scaled == scaled);
alpar@9:       _glp_check_kkt(lp, GLP_SOL, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->pe_ae_max = ae_max;
alpar@9:       kkt->pe_ae_row = ae_ind;
alpar@9:       kkt->pe_re_max = re_max;
alpar@9:       kkt->pe_re_row = re_ind;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->pe_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->pe_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->pe_quality = 'L';
alpar@9:       else
alpar@9:          kkt->pe_quality = '?';
alpar@9:       _glp_check_kkt(lp, GLP_SOL, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->pb_ae_max = ae_max;
alpar@9:       kkt->pb_ae_ind = ae_ind;
alpar@9:       kkt->pb_re_max = re_max;
alpar@9:       kkt->pb_re_ind = re_ind;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->pb_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->pb_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->pb_quality = 'L';
alpar@9:       else
alpar@9:          kkt->pb_quality = '?';
alpar@9:       _glp_check_kkt(lp, GLP_SOL, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->de_ae_max = ae_max;
alpar@9:       if (ae_ind == 0)
alpar@9:          kkt->de_ae_col = 0;
alpar@9:       else
alpar@9:          kkt->de_ae_col = ae_ind - lp->m;
alpar@9:       kkt->de_re_max = re_max;
alpar@9:       if (re_ind == 0)
alpar@9:          kkt->de_re_col = 0;
alpar@9:       else
alpar@9:          kkt->de_re_col = ae_ind - lp->m;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->de_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->de_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->de_quality = 'L';
alpar@9:       else
alpar@9:          kkt->de_quality = '?';
alpar@9:       _glp_check_kkt(lp, GLP_SOL, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->db_ae_max = ae_max;
alpar@9:       kkt->db_ae_ind = ae_ind;
alpar@9:       kkt->db_re_max = re_max;
alpar@9:       kkt->db_re_ind = re_ind;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->db_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->db_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->db_quality = 'L';
alpar@9:       else
alpar@9:          kkt->db_quality = '?';
alpar@9:       kkt->cs_ae_max = 0.0, kkt->cs_ae_ind = 0;
alpar@9:       kkt->cs_re_max = 0.0, kkt->cs_re_ind = 0;
alpar@9:       kkt->cs_quality = 'H';
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_warm_up(LPX *lp)
alpar@9: {     /* "warm up" LP basis */
alpar@9:       int ret;
alpar@9:       ret = glp_warm_up(lp);
alpar@9:       if (ret == 0)
alpar@9:          ret = LPX_E_OK;
alpar@9:       else if (ret == GLP_EBADB)
alpar@9:          ret = LPX_E_BADB;
alpar@9:       else if (ret == GLP_ESING)
alpar@9:          ret = LPX_E_SING;
alpar@9:       else if (ret == GLP_ECOND)
alpar@9:          ret = LPX_E_SING;
alpar@9:       else
alpar@9:          xassert(ret != ret);
alpar@9:       return ret;
alpar@9: }
alpar@9: 
alpar@9: int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[])
alpar@9: {     /* compute row of the simplex tableau */
alpar@9:       return glp_eval_tab_row(lp, k, ind, val);
alpar@9: }
alpar@9: 
alpar@9: int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[])
alpar@9: {     /* compute column of the simplex tableau */
alpar@9:       return glp_eval_tab_col(lp, k, ind, val);
alpar@9: }
alpar@9: 
alpar@9: int lpx_transform_row(LPX *lp, int len, int ind[], double val[])
alpar@9: {     /* transform explicitly specified row */
alpar@9:       return glp_transform_row(lp, len, ind, val);
alpar@9: }
alpar@9: 
alpar@9: int lpx_transform_col(LPX *lp, int len, int ind[], double val[])
alpar@9: {     /* transform explicitly specified column */
alpar@9:       return glp_transform_col(lp, len, ind, val);
alpar@9: }
alpar@9: 
alpar@9: int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
alpar@9:       const double val[], int how, double tol)
alpar@9: {     /* perform primal ratio test */
alpar@9:       int piv;
alpar@9:       piv = glp_prim_rtest(lp, len, ind, val, how, tol);
alpar@9:       xassert(0 <= piv && piv <= len);
alpar@9:       return piv == 0 ? 0 : ind[piv];
alpar@9: }
alpar@9: 
alpar@9: int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
alpar@9:       const double val[], int how, double tol)
alpar@9: {     /* perform dual ratio test */
alpar@9:       int piv;
alpar@9:       piv = glp_dual_rtest(lp, len, ind, val, how, tol);
alpar@9:       xassert(0 <= piv && piv <= len);
alpar@9:       return piv == 0 ? 0 : ind[piv];
alpar@9: }
alpar@9: 
alpar@9: int lpx_interior(LPX *lp)
alpar@9: {     /* easy-to-use driver to the interior-point method */
alpar@9:       int ret;
alpar@9:       ret = glp_interior(lp, NULL);
alpar@9:       switch (ret)
alpar@9:       {  case 0:           ret = LPX_E_OK;      break;
alpar@9:          case GLP_EFAIL:   ret = LPX_E_FAULT;   break;
alpar@9:          case GLP_ENOFEAS: ret = LPX_E_NOFEAS;  break;
alpar@9:          case GLP_ENOCVG:  ret = LPX_E_NOCONV;  break;
alpar@9:          case GLP_EITLIM:  ret = LPX_E_ITLIM;   break;
alpar@9:          case GLP_EINSTAB: ret = LPX_E_INSTAB;  break;
alpar@9:          default:          xassert(ret != ret);
alpar@9:       }
alpar@9:       return ret;
alpar@9: }
alpar@9: 
alpar@9: int lpx_ipt_status(glp_prob *lp)
alpar@9: {     /* retrieve status of interior-point solution */
alpar@9:       int status;
alpar@9:       switch (glp_ipt_status(lp))
alpar@9:       {  case GLP_UNDEF:  status = LPX_T_UNDEF;  break;
alpar@9:          case GLP_OPT:    status = LPX_T_OPT;    break;
alpar@9:          default:         xassert(lp != lp);
alpar@9:       }
alpar@9:       return status;
alpar@9: }
alpar@9: 
alpar@9: double lpx_ipt_obj_val(LPX *lp)
alpar@9: {     /* retrieve objective value (interior point) */
alpar@9:       return glp_ipt_obj_val(lp);
alpar@9: }
alpar@9: 
alpar@9: double lpx_ipt_row_prim(LPX *lp, int i)
alpar@9: {     /* retrieve row primal value (interior point) */
alpar@9:       return glp_ipt_row_prim(lp, i);
alpar@9: }
alpar@9: 
alpar@9: double lpx_ipt_row_dual(LPX *lp, int i)
alpar@9: {     /* retrieve row dual value (interior point) */
alpar@9:       return glp_ipt_row_dual(lp, i);
alpar@9: }
alpar@9: 
alpar@9: double lpx_ipt_col_prim(LPX *lp, int j)
alpar@9: {     /* retrieve column primal value (interior point) */
alpar@9:       return glp_ipt_col_prim(lp, j);
alpar@9: }
alpar@9: 
alpar@9: double lpx_ipt_col_dual(LPX *lp, int j)
alpar@9: {     /* retrieve column dual value (interior point) */
alpar@9:       return glp_ipt_col_dual(lp, j);
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_class(LPX *lp, int klass)
alpar@9: {     /* set problem class */
alpar@9:       xassert(lp == lp);
alpar@9:       if (!(klass == LPX_LP || klass == LPX_MIP))
alpar@9:          xerror("lpx_set_class: invalid problem class\n");
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_class(LPX *lp)
alpar@9: {     /* determine problem klass */
alpar@9:       return glp_get_num_int(lp) == 0 ? LPX_LP : LPX_MIP;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_col_kind(LPX *lp, int j, int kind)
alpar@9: {     /* set (change) column kind */
alpar@9:       glp_set_col_kind(lp, j, kind - LPX_CV + GLP_CV);
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_col_kind(LPX *lp, int j)
alpar@9: {     /* retrieve column kind */
alpar@9:       return glp_get_col_kind(lp, j) == GLP_CV ? LPX_CV : LPX_IV;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_num_int(LPX *lp)
alpar@9: {     /* retrieve number of integer columns */
alpar@9:       return glp_get_num_int(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_num_bin(LPX *lp)
alpar@9: {     /* retrieve number of binary columns */
alpar@9:       return glp_get_num_bin(lp);
alpar@9: }
alpar@9: 
alpar@9: static int solve_mip(LPX *lp, int presolve)
alpar@9: {     glp_iocp parm;
alpar@9:       int ret;
alpar@9:       glp_init_iocp(&parm);
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_MSGLEV))
alpar@9:       {  case 0:  parm.msg_lev = GLP_MSG_OFF;   break;
alpar@9:          case 1:  parm.msg_lev = GLP_MSG_ERR;   break;
alpar@9:          case 2:  parm.msg_lev = GLP_MSG_ON;    break;
alpar@9:          case 3:  parm.msg_lev = GLP_MSG_ALL;   break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_BRANCH))
alpar@9:       {  case 0:  parm.br_tech = GLP_BR_FFV;    break;
alpar@9:          case 1:  parm.br_tech = GLP_BR_LFV;    break;
alpar@9:          case 2:  parm.br_tech = GLP_BR_DTH;    break;
alpar@9:          case 3:  parm.br_tech = GLP_BR_MFV;    break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       switch (lpx_get_int_parm(lp, LPX_K_BTRACK))
alpar@9:       {  case 0:  parm.bt_tech = GLP_BT_DFS;    break;
alpar@9:          case 1:  parm.bt_tech = GLP_BT_BFS;    break;
alpar@9:          case 2:  parm.bt_tech = GLP_BT_BPH;    break;
alpar@9:          case 3:  parm.bt_tech = GLP_BT_BLB;    break;
alpar@9:          default: xassert(lp != lp);
alpar@9:       }
alpar@9:       parm.tol_int = lpx_get_real_parm(lp, LPX_K_TOLINT);
alpar@9:       parm.tol_obj = lpx_get_real_parm(lp, LPX_K_TOLOBJ);
alpar@9:       if (lpx_get_real_parm(lp, LPX_K_TMLIM) < 0.0 ||
alpar@9:           lpx_get_real_parm(lp, LPX_K_TMLIM) > 1e6)
alpar@9:          parm.tm_lim = INT_MAX;
alpar@9:       else
alpar@9:          parm.tm_lim =
alpar@9:             (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_TMLIM));
alpar@9:       parm.mip_gap = lpx_get_real_parm(lp, LPX_K_MIPGAP);
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_GOMORY)
alpar@9:          parm.gmi_cuts = GLP_ON;
alpar@9:       else
alpar@9:          parm.gmi_cuts = GLP_OFF;
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_MIR)
alpar@9:          parm.mir_cuts = GLP_ON;
alpar@9:       else
alpar@9:          parm.mir_cuts = GLP_OFF;
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_COVER)
alpar@9:          parm.cov_cuts = GLP_ON;
alpar@9:       else
alpar@9:          parm.cov_cuts = GLP_OFF;
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_CLIQUE)
alpar@9:          parm.clq_cuts = GLP_ON;
alpar@9:       else
alpar@9:          parm.clq_cuts = GLP_OFF;
alpar@9:       parm.presolve = presolve;
alpar@9:       if (lpx_get_int_parm(lp, LPX_K_BINARIZE))
alpar@9:          parm.binarize = GLP_ON;
alpar@9:       ret = glp_intopt(lp, &parm);
alpar@9:       switch (ret)
alpar@9:       {  case 0:           ret = LPX_E_OK;      break;
alpar@9:          case GLP_ENOPFS:  ret = LPX_E_NOPFS;   break;
alpar@9:          case GLP_ENODFS:  ret = LPX_E_NODFS;   break;
alpar@9:          case GLP_EBOUND:
alpar@9:          case GLP_EROOT:   ret = LPX_E_FAULT;   break;
alpar@9:          case GLP_EFAIL:   ret = LPX_E_SING;    break;
alpar@9:          case GLP_EMIPGAP: ret = LPX_E_MIPGAP;  break;
alpar@9:          case GLP_ETMLIM:  ret = LPX_E_TMLIM;   break;
alpar@9:          default:          xassert(ret != ret);
alpar@9:       }
alpar@9:       return ret;
alpar@9: }
alpar@9: 
alpar@9: int lpx_integer(LPX *lp)
alpar@9: {     /* easy-to-use driver to the branch-and-bound method */
alpar@9:       return solve_mip(lp, GLP_OFF);
alpar@9: }
alpar@9: 
alpar@9: int lpx_intopt(LPX *lp)
alpar@9: {     /* easy-to-use driver to the branch-and-bound method */
alpar@9:       return solve_mip(lp, GLP_ON);
alpar@9: }
alpar@9: 
alpar@9: int lpx_mip_status(glp_prob *lp)
alpar@9: {     /* retrieve status of MIP solution */
alpar@9:       int status;
alpar@9:       switch (glp_mip_status(lp))
alpar@9:       {  case GLP_UNDEF:  status = LPX_I_UNDEF;  break;
alpar@9:          case GLP_OPT:    status = LPX_I_OPT;    break;
alpar@9:          case GLP_FEAS:   status = LPX_I_FEAS;   break;
alpar@9:          case GLP_NOFEAS: status = LPX_I_NOFEAS; break;
alpar@9:          default:         xassert(lp != lp);
alpar@9:       }
alpar@9:       return status;
alpar@9: }
alpar@9: 
alpar@9: double lpx_mip_obj_val(LPX *lp)
alpar@9: {     /* retrieve objective value (MIP solution) */
alpar@9:       return glp_mip_obj_val(lp);
alpar@9: }
alpar@9: 
alpar@9: double lpx_mip_row_val(LPX *lp, int i)
alpar@9: {     /* retrieve row value (MIP solution) */
alpar@9:       return glp_mip_row_val(lp, i);
alpar@9: }
alpar@9: 
alpar@9: double lpx_mip_col_val(LPX *lp, int j)
alpar@9: {     /* retrieve column value (MIP solution) */
alpar@9:       return glp_mip_col_val(lp, j);
alpar@9: }
alpar@9: 
alpar@9: void lpx_check_int(LPX *lp, LPXKKT *kkt)
alpar@9: {     /* check integer feasibility conditions */
alpar@9:       int ae_ind, re_ind;
alpar@9:       double ae_max, re_max;
alpar@9:       _glp_check_kkt(lp, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->pe_ae_max = ae_max;
alpar@9:       kkt->pe_ae_row = ae_ind;
alpar@9:       kkt->pe_re_max = re_max;
alpar@9:       kkt->pe_re_row = re_ind;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->pe_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->pe_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->pe_quality = 'L';
alpar@9:       else
alpar@9:          kkt->pe_quality = '?';
alpar@9:       _glp_check_kkt(lp, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
alpar@9:          &re_ind);
alpar@9:       kkt->pb_ae_max = ae_max;
alpar@9:       kkt->pb_ae_ind = ae_ind;
alpar@9:       kkt->pb_re_max = re_max;
alpar@9:       kkt->pb_re_ind = re_ind;
alpar@9:       if (re_max <= 1e-9)
alpar@9:          kkt->pb_quality = 'H';
alpar@9:       else if (re_max <= 1e-6)
alpar@9:          kkt->pb_quality = 'M';
alpar@9:       else if (re_max <= 1e-3)
alpar@9:          kkt->pb_quality = 'L';
alpar@9:       else
alpar@9:          kkt->pb_quality = '?';
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: #if 1 /* 17/XI-2009 */
alpar@9: static void reset_parms(LPX *lp)
alpar@9: {     /* reset control parameters to default values */
alpar@9:       struct LPXCPS *cps = lp->parms;
alpar@9:       xassert(cps != NULL);
alpar@9:       cps->msg_lev  = 3;
alpar@9:       cps->scale    = 1;
alpar@9:       cps->dual     = 0;
alpar@9:       cps->price    = 1;
alpar@9:       cps->relax    = 0.07;
alpar@9:       cps->tol_bnd  = 1e-7;
alpar@9:       cps->tol_dj   = 1e-7;
alpar@9:       cps->tol_piv  = 1e-9;
alpar@9:       cps->round    = 0;
alpar@9:       cps->obj_ll   = -DBL_MAX;
alpar@9:       cps->obj_ul   = +DBL_MAX;
alpar@9:       cps->it_lim   = -1;
alpar@9: #if 0 /* 02/XII-2010 */
alpar@9:       lp->it_cnt   = 0;
alpar@9: #endif
alpar@9:       cps->tm_lim   = -1.0;
alpar@9:       cps->out_frq  = 200;
alpar@9:       cps->out_dly  = 0.0;
alpar@9:       cps->branch   = 2;
alpar@9:       cps->btrack   = 3;
alpar@9:       cps->tol_int  = 1e-5;
alpar@9:       cps->tol_obj  = 1e-7;
alpar@9:       cps->mps_info = 1;
alpar@9:       cps->mps_obj  = 2;
alpar@9:       cps->mps_orig = 0;
alpar@9:       cps->mps_wide = 1;
alpar@9:       cps->mps_free = 0;
alpar@9:       cps->mps_skip = 0;
alpar@9:       cps->lpt_orig = 0;
alpar@9:       cps->presol = 0;
alpar@9:       cps->binarize = 0;
alpar@9:       cps->use_cuts = 0;
alpar@9:       cps->mip_gap = 0.0;
alpar@9:       return;
alpar@9: }
alpar@9: #endif
alpar@9: 
alpar@9: #if 1 /* 17/XI-2009 */
alpar@9: static struct LPXCPS *access_parms(LPX *lp)
alpar@9: {     /* allocate and initialize control parameters, if necessary */
alpar@9:       if (lp->parms == NULL)
alpar@9:       {  lp->parms = xmalloc(sizeof(struct LPXCPS));
alpar@9:          reset_parms(lp);
alpar@9:       }
alpar@9:       return lp->parms;
alpar@9: }
alpar@9: #endif
alpar@9: 
alpar@9: #if 1 /* 17/XI-2009 */
alpar@9: void lpx_reset_parms(LPX *lp)
alpar@9: {     /* reset control parameters to default values */
alpar@9:       access_parms(lp);
alpar@9:       reset_parms(lp);
alpar@9:       return;
alpar@9: }
alpar@9: #endif
alpar@9: 
alpar@9: void lpx_set_int_parm(LPX *lp, int parm, int val)
alpar@9: {     /* set (change) integer control parameter */
alpar@9: #if 0 /* 17/XI-2009 */
alpar@9:       struct LPXCPS *cps = lp->cps;
alpar@9: #else
alpar@9:       struct LPXCPS *cps = access_parms(lp);
alpar@9: #endif
alpar@9:       switch (parm)
alpar@9:       {  case LPX_K_MSGLEV:
alpar@9:             if (!(0 <= val && val <= 3))
alpar@9:                xerror("lpx_set_int_parm: MSGLEV = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->msg_lev = val;
alpar@9:             break;
alpar@9:          case LPX_K_SCALE:
alpar@9:             if (!(0 <= val && val <= 3))
alpar@9:                xerror("lpx_set_int_parm: SCALE = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->scale = val;
alpar@9:             break;
alpar@9:          case LPX_K_DUAL:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: DUAL = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->dual = val;
alpar@9:             break;
alpar@9:          case LPX_K_PRICE:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: PRICE = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->price = val;
alpar@9:             break;
alpar@9:          case LPX_K_ROUND:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: ROUND = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->round = val;
alpar@9:             break;
alpar@9:          case LPX_K_ITLIM:
alpar@9:             cps->it_lim = val;
alpar@9:             break;
alpar@9:          case LPX_K_ITCNT:
alpar@9:             lp->it_cnt = val;
alpar@9:             break;
alpar@9:          case LPX_K_OUTFRQ:
alpar@9:             if (!(val > 0))
alpar@9:                xerror("lpx_set_int_parm: OUTFRQ = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->out_frq = val;
alpar@9:             break;
alpar@9:          case LPX_K_BRANCH:
alpar@9:             if (!(val == 0 || val == 1 || val == 2 || val == 3))
alpar@9:                xerror("lpx_set_int_parm: BRANCH = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->branch = val;
alpar@9:             break;
alpar@9:          case LPX_K_BTRACK:
alpar@9:             if (!(val == 0 || val == 1 || val == 2 || val == 3))
alpar@9:                xerror("lpx_set_int_parm: BTRACK = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->btrack = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSINFO:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: MPSINFO = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_info = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSOBJ:
alpar@9:             if (!(val == 0 || val == 1 || val == 2))
alpar@9:                xerror("lpx_set_int_parm: MPSOBJ = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_obj = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSORIG:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: MPSORIG = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_orig = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSWIDE:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: MPSWIDE = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_wide = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSFREE:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: MPSFREE = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_free = val;
alpar@9:             break;
alpar@9:          case LPX_K_MPSSKIP:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: MPSSKIP = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mps_skip = val;
alpar@9:             break;
alpar@9:          case LPX_K_LPTORIG:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: LPTORIG = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->lpt_orig = val;
alpar@9:             break;
alpar@9:          case LPX_K_PRESOL:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: PRESOL = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->presol = val;
alpar@9:             break;
alpar@9:          case LPX_K_BINARIZE:
alpar@9:             if (!(val == 0 || val == 1))
alpar@9:                xerror("lpx_set_int_parm: BINARIZE = %d; invalid value\n"
alpar@9:                   , val);
alpar@9:             cps->binarize = val;
alpar@9:             break;
alpar@9:          case LPX_K_USECUTS:
alpar@9:             if (val & ~LPX_C_ALL)
alpar@9:             xerror("lpx_set_int_parm: USECUTS = 0x%X; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->use_cuts = val;
alpar@9:             break;
alpar@9:          case LPX_K_BFTYPE:
alpar@9: #if 0
alpar@9:             if (!(1 <= val && val <= 3))
alpar@9:                xerror("lpx_set_int_parm: BFTYPE = %d; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->bf_type = val;
alpar@9: #else
alpar@9:             {  glp_bfcp parm;
alpar@9:                glp_get_bfcp(lp, &parm);
alpar@9:                switch (val)
alpar@9:                {  case 1:
alpar@9:                      parm.type = GLP_BF_FT; break;
alpar@9:                   case 2:
alpar@9:                      parm.type = GLP_BF_BG; break;
alpar@9:                   case 3:
alpar@9:                      parm.type = GLP_BF_GR; break;
alpar@9:                   default:
alpar@9:                      xerror("lpx_set_int_parm: BFTYPE = %d; invalid val"
alpar@9:                         "ue\n", val);
alpar@9:                }
alpar@9:                glp_set_bfcp(lp, &parm);
alpar@9:             }
alpar@9: #endif
alpar@9:             break;
alpar@9:          default:
alpar@9:             xerror("lpx_set_int_parm: parm = %d; invalid parameter\n",
alpar@9:                parm);
alpar@9:       }
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: int lpx_get_int_parm(LPX *lp, int parm)
alpar@9: {     /* query integer control parameter */
alpar@9: #if 0 /* 17/XI-2009 */
alpar@9:       struct LPXCPS *cps = lp->cps;
alpar@9: #else
alpar@9:       struct LPXCPS *cps = access_parms(lp);
alpar@9: #endif
alpar@9:       int val = 0;
alpar@9:       switch (parm)
alpar@9:       {  case LPX_K_MSGLEV:
alpar@9:             val = cps->msg_lev; break;
alpar@9:          case LPX_K_SCALE:
alpar@9:             val = cps->scale; break;
alpar@9:          case LPX_K_DUAL:
alpar@9:             val = cps->dual; break;
alpar@9:          case LPX_K_PRICE:
alpar@9:             val = cps->price; break;
alpar@9:          case LPX_K_ROUND:
alpar@9:             val = cps->round; break;
alpar@9:          case LPX_K_ITLIM:
alpar@9:             val = cps->it_lim; break;
alpar@9:          case LPX_K_ITCNT:
alpar@9:             val = lp->it_cnt; break;
alpar@9:          case LPX_K_OUTFRQ:
alpar@9:             val = cps->out_frq; break;
alpar@9:          case LPX_K_BRANCH:
alpar@9:             val = cps->branch; break;
alpar@9:          case LPX_K_BTRACK:
alpar@9:             val = cps->btrack; break;
alpar@9:          case LPX_K_MPSINFO:
alpar@9:             val = cps->mps_info; break;
alpar@9:          case LPX_K_MPSOBJ:
alpar@9:             val = cps->mps_obj; break;
alpar@9:          case LPX_K_MPSORIG:
alpar@9:             val = cps->mps_orig; break;
alpar@9:          case LPX_K_MPSWIDE:
alpar@9:             val = cps->mps_wide; break;
alpar@9:          case LPX_K_MPSFREE:
alpar@9:             val = cps->mps_free; break;
alpar@9:          case LPX_K_MPSSKIP:
alpar@9:             val = cps->mps_skip; break;
alpar@9:          case LPX_K_LPTORIG:
alpar@9:             val = cps->lpt_orig; break;
alpar@9:          case LPX_K_PRESOL:
alpar@9:             val = cps->presol; break;
alpar@9:          case LPX_K_BINARIZE:
alpar@9:             val = cps->binarize; break;
alpar@9:          case LPX_K_USECUTS:
alpar@9:             val = cps->use_cuts; break;
alpar@9:          case LPX_K_BFTYPE:
alpar@9: #if 0
alpar@9:             val = cps->bf_type; break;
alpar@9: #else
alpar@9:             {  glp_bfcp parm;
alpar@9:                glp_get_bfcp(lp, &parm);
alpar@9:                switch (parm.type)
alpar@9:                {  case GLP_BF_FT:
alpar@9:                      val = 1; break;
alpar@9:                   case GLP_BF_BG:
alpar@9:                      val = 2; break;
alpar@9:                   case GLP_BF_GR:
alpar@9:                      val = 3; break;
alpar@9:                   default:
alpar@9:                      xassert(lp != lp);
alpar@9:                }
alpar@9:             }
alpar@9:             break;
alpar@9: #endif
alpar@9:          default:
alpar@9:             xerror("lpx_get_int_parm: parm = %d; invalid parameter\n",
alpar@9:                parm);
alpar@9:       }
alpar@9:       return val;
alpar@9: }
alpar@9: 
alpar@9: void lpx_set_real_parm(LPX *lp, int parm, double val)
alpar@9: {     /* set (change) real control parameter */
alpar@9: #if 0 /* 17/XI-2009 */
alpar@9:       struct LPXCPS *cps = lp->cps;
alpar@9: #else
alpar@9:       struct LPXCPS *cps = access_parms(lp);
alpar@9: #endif
alpar@9:       switch (parm)
alpar@9:       {  case LPX_K_RELAX:
alpar@9:             if (!(0.0 <= val && val <= 1.0))
alpar@9:                xerror("lpx_set_real_parm: RELAX = %g; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->relax = val;
alpar@9:             break;
alpar@9:          case LPX_K_TOLBND:
alpar@9:             if (!(DBL_EPSILON <= val && val <= 0.001))
alpar@9:                xerror("lpx_set_real_parm: TOLBND = %g; invalid value\n",
alpar@9:                   val);
alpar@9: #if 0
alpar@9:             if (cps->tol_bnd > val)
alpar@9:             {  /* invalidate the basic solution */
alpar@9:                lp->p_stat = LPX_P_UNDEF;
alpar@9:                lp->d_stat = LPX_D_UNDEF;
alpar@9:             }
alpar@9: #endif
alpar@9:             cps->tol_bnd = val;
alpar@9:             break;
alpar@9:          case LPX_K_TOLDJ:
alpar@9:             if (!(DBL_EPSILON <= val && val <= 0.001))
alpar@9:                xerror("lpx_set_real_parm: TOLDJ = %g; invalid value\n",
alpar@9:                   val);
alpar@9: #if 0
alpar@9:             if (cps->tol_dj > val)
alpar@9:             {  /* invalidate the basic solution */
alpar@9:                lp->p_stat = LPX_P_UNDEF;
alpar@9:                lp->d_stat = LPX_D_UNDEF;
alpar@9:             }
alpar@9: #endif
alpar@9:             cps->tol_dj = val;
alpar@9:             break;
alpar@9:          case LPX_K_TOLPIV:
alpar@9:             if (!(DBL_EPSILON <= val && val <= 0.001))
alpar@9:                xerror("lpx_set_real_parm: TOLPIV = %g; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->tol_piv = val;
alpar@9:             break;
alpar@9:          case LPX_K_OBJLL:
alpar@9:             cps->obj_ll = val;
alpar@9:             break;
alpar@9:          case LPX_K_OBJUL:
alpar@9:             cps->obj_ul = val;
alpar@9:             break;
alpar@9:          case LPX_K_TMLIM:
alpar@9:             cps->tm_lim = val;
alpar@9:             break;
alpar@9:          case LPX_K_OUTDLY:
alpar@9:             cps->out_dly = val;
alpar@9:             break;
alpar@9:          case LPX_K_TOLINT:
alpar@9:             if (!(DBL_EPSILON <= val && val <= 0.001))
alpar@9:                xerror("lpx_set_real_parm: TOLINT = %g; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->tol_int = val;
alpar@9:             break;
alpar@9:          case LPX_K_TOLOBJ:
alpar@9:             if (!(DBL_EPSILON <= val && val <= 0.001))
alpar@9:                xerror("lpx_set_real_parm: TOLOBJ = %g; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->tol_obj = val;
alpar@9:             break;
alpar@9:          case LPX_K_MIPGAP:
alpar@9:             if (val < 0.0)
alpar@9:                xerror("lpx_set_real_parm: MIPGAP = %g; invalid value\n",
alpar@9:                   val);
alpar@9:             cps->mip_gap = val;
alpar@9:             break;
alpar@9:          default:
alpar@9:             xerror("lpx_set_real_parm: parm = %d; invalid parameter\n",
alpar@9:                parm);
alpar@9:       }
alpar@9:       return;
alpar@9: }
alpar@9: 
alpar@9: double lpx_get_real_parm(LPX *lp, int parm)
alpar@9: {     /* query real control parameter */
alpar@9: #if 0 /* 17/XI-2009 */
alpar@9:       struct LPXCPS *cps = lp->cps;
alpar@9: #else
alpar@9:       struct LPXCPS *cps = access_parms(lp);
alpar@9: #endif
alpar@9:       double val = 0.0;
alpar@9:       switch (parm)
alpar@9:       {  case LPX_K_RELAX:
alpar@9:             val = cps->relax;
alpar@9:             break;
alpar@9:          case LPX_K_TOLBND:
alpar@9:             val = cps->tol_bnd;
alpar@9:             break;
alpar@9:          case LPX_K_TOLDJ:
alpar@9:             val = cps->tol_dj;
alpar@9:             break;
alpar@9:          case LPX_K_TOLPIV:
alpar@9:             val = cps->tol_piv;
alpar@9:             break;
alpar@9:          case LPX_K_OBJLL:
alpar@9:             val = cps->obj_ll;
alpar@9:             break;
alpar@9:          case LPX_K_OBJUL:
alpar@9:             val = cps->obj_ul;
alpar@9:             break;
alpar@9:          case LPX_K_TMLIM:
alpar@9:             val = cps->tm_lim;
alpar@9:             break;
alpar@9:          case LPX_K_OUTDLY:
alpar@9:             val = cps->out_dly;
alpar@9:             break;
alpar@9:          case LPX_K_TOLINT:
alpar@9:             val = cps->tol_int;
alpar@9:             break;
alpar@9:          case LPX_K_TOLOBJ:
alpar@9:             val = cps->tol_obj;
alpar@9:             break;
alpar@9:          case LPX_K_MIPGAP:
alpar@9:             val = cps->mip_gap;
alpar@9:             break;
alpar@9:          default:
alpar@9:             xerror("lpx_get_real_parm: parm = %d; invalid parameter\n",
alpar@9:                parm);
alpar@9:       }
alpar@9:       return val;
alpar@9: }
alpar@9: 
alpar@9: LPX *lpx_read_mps(const char *fname)
alpar@9: {     /* read problem data in fixed MPS format */
alpar@9:       LPX *lp = lpx_create_prob();
alpar@9:       if (glp_read_mps(lp, GLP_MPS_DECK, NULL, fname))
alpar@9:          lpx_delete_prob(lp), lp = NULL;
alpar@9:       return lp;
alpar@9: }
alpar@9: 
alpar@9: int lpx_write_mps(LPX *lp, const char *fname)
alpar@9: {     /* write problem data in fixed MPS format */
alpar@9:       return glp_write_mps(lp, GLP_MPS_DECK, NULL, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_read_bas(LPX *lp, const char *fname)
alpar@9: {     /* read LP basis in fixed MPS format */
alpar@9: #if 0 /* 13/IV-2009 */
alpar@9:       return read_bas(lp, fname);
alpar@9: #else
alpar@9:       xassert(lp == lp);
alpar@9:       xassert(fname == fname);
alpar@9:       xerror("lpx_read_bas: operation not supported\n");
alpar@9:       return 0;
alpar@9: #endif
alpar@9: }
alpar@9: 
alpar@9: int lpx_write_bas(LPX *lp, const char *fname)
alpar@9: {     /* write LP basis in fixed MPS format */
alpar@9: #if 0 /* 13/IV-2009 */
alpar@9:       return write_bas(lp, fname);
alpar@9: #else
alpar@9:       xassert(lp == lp);
alpar@9:       xassert(fname == fname);
alpar@9:       xerror("lpx_write_bas: operation not supported\n");
alpar@9:       return 0;
alpar@9: #endif
alpar@9: }
alpar@9: 
alpar@9: LPX *lpx_read_freemps(const char *fname)
alpar@9: {     /* read problem data in free MPS format */
alpar@9:       LPX *lp = lpx_create_prob();
alpar@9:       if (glp_read_mps(lp, GLP_MPS_FILE, NULL, fname))
alpar@9:          lpx_delete_prob(lp), lp = NULL;
alpar@9:       return lp;
alpar@9: }
alpar@9: 
alpar@9: int lpx_write_freemps(LPX *lp, const char *fname)
alpar@9: {     /* write problem data in free MPS format */
alpar@9:       return glp_write_mps(lp, GLP_MPS_FILE, NULL, fname);
alpar@9: }
alpar@9: 
alpar@9: LPX *lpx_read_cpxlp(const char *fname)
alpar@9: {     /* read problem data in CPLEX LP format */
alpar@9:       LPX *lp;
alpar@9:       lp = lpx_create_prob();
alpar@9:       if (glp_read_lp(lp, NULL, fname))
alpar@9:          lpx_delete_prob(lp), lp = NULL;
alpar@9:       return lp;
alpar@9: }
alpar@9: 
alpar@9: int lpx_write_cpxlp(LPX *lp, const char *fname)
alpar@9: {     /* write problem data in CPLEX LP format */
alpar@9:       return glp_write_lp(lp, NULL, fname);
alpar@9: }
alpar@9: 
alpar@9: LPX *lpx_read_model(const char *model, const char *data, const char
alpar@9:       *output)
alpar@9: {     /* read LP/MIP model written in GNU MathProg language */
alpar@9:       LPX *lp = NULL;
alpar@9:       glp_tran *tran;
alpar@9:       /* allocate the translator workspace */
alpar@9:       tran = glp_mpl_alloc_wksp();
alpar@9:       /* read model section and optional data section */
alpar@9:       if (glp_mpl_read_model(tran, model, data != NULL)) goto done;
alpar@9:       /* read separate data section, if required */
alpar@9:       if (data != NULL)
alpar@9:          if (glp_mpl_read_data(tran, data)) goto done;
alpar@9:       /* generate the model */
alpar@9:       if (glp_mpl_generate(tran, output)) goto done;
alpar@9:       /* build the problem instance from the model */
alpar@9:       lp = glp_create_prob();
alpar@9:       glp_mpl_build_prob(tran, lp);
alpar@9: done: /* free the translator workspace */
alpar@9:       glp_mpl_free_wksp(tran);
alpar@9:       /* bring the problem object to the calling program */
alpar@9:       return lp;
alpar@9: }
alpar@9: 
alpar@9: int lpx_print_prob(LPX *lp, const char *fname)
alpar@9: {     /* write problem data in plain text format */
alpar@9:       return glp_write_lp(lp, NULL, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_print_sol(LPX *lp, const char *fname)
alpar@9: {     /* write LP problem solution in printable format */
alpar@9:       return glp_print_sol(lp, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_print_sens_bnds(LPX *lp, const char *fname)
alpar@9: {     /* write bounds sensitivity information */
alpar@9:       if (glp_get_status(lp) == GLP_OPT && !glp_bf_exists(lp))
alpar@9:          glp_factorize(lp);
alpar@9:       return glp_print_ranges(lp, 0, NULL, 0, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_print_ips(LPX *lp, const char *fname)
alpar@9: {     /* write interior point solution in printable format */
alpar@9:       return glp_print_ipt(lp, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_print_mip(LPX *lp, const char *fname)
alpar@9: {     /* write MIP problem solution in printable format */
alpar@9:       return glp_print_mip(lp, fname);
alpar@9: }
alpar@9: 
alpar@9: int lpx_is_b_avail(glp_prob *lp)
alpar@9: {     /* check if LP basis is available */
alpar@9:       return glp_bf_exists(lp);
alpar@9: }
alpar@9: 
alpar@9: int lpx_main(int argc, const char *argv[])
alpar@9: {     /* stand-alone LP/MIP solver */
alpar@9:       return glp_main(argc, argv);
alpar@9: }
alpar@9: 
alpar@9: /* eof */