jengelh/4ti2
SHA256
1
0
Fork 0
forked from pool/4ti2
Code Pull Requests Activity
58f32226c9
4ti2/4ti2-glpk.diff

3068 lines
102 KiB
Diff
Raw Blame History

From: Jan Engelhardt <jengelh@inai.de>
Date: 2014-02-05 00:22:20.673919835 +0100
libglpk has a wrapper emulating the old API, but it does not export
its function (*aagh!) Copy the files and build it ourselves. Meh.
---
m4/glpk-check.m4 | 2
src/groebner/Bounded.cpp | 1
src/groebner/Makefile.am | 6
src/groebner/dmp.h | 63 +
src/groebner/env.h | 207 ++++++
src/groebner/glpapi.h | 309 +++++++++
src/groebner/glpavl.h | 123 +++
src/groebner/glpbfd.h | 73 ++
src/groebner/glplpx.h | 579 +++++++++++++++++
src/groebner/glplpx01.c | 1542 +++++++++++++++++++++++++++++++++++++++++++++++
src/groebner/stdc.h | 42 +
11 files changed, 2946 insertions(+), 1 deletion(-)
Index: 4ti2-1.6/m4/glpk-check.m4
===================================================================
--- 4ti2-1.6.orig/m4/glpk-check.m4
+++ 4ti2-1.6/m4/glpk-check.m4
@@ -58,7 +58,7 @@ for GLPK_HOME in ${GLPK_HOME_PATH}
AC_LINK_IFELSE(AC_LANG_PROGRAM([extern "C" {
#include <glpk.h>
-}], [LPX *lpx = lpx_create_prob(); lpx_delete_prob(lpx); ]),
+}], [glp_prob *lpx = glp_create_prob(); glp_delete_prob(lpx); ]),
[
AC_MSG_RESULT(found)
AC_SUBST(GLPK_CFLAGS)
Index: 4ti2-1.6/src/groebner/Bounded.cpp
===================================================================
--- 4ti2-1.6.orig/src/groebner/Bounded.cpp
+++ 4ti2-1.6/src/groebner/Bounded.cpp
@@ -37,6 +37,7 @@ Foundation, Inc., 51 Franklin Street, Fi
extern "C" {
#include "glpk.h"
+#include "glplpx.h"
}
// TODO: Fix this up.
Index: 4ti2-1.6/src/groebner/Makefile.am
===================================================================
--- 4ti2-1.6.orig/src/groebner/Makefile.am
+++ 4ti2-1.6/src/groebner/Makefile.am
@@ -26,6 +26,7 @@ endif
lib_LTLIBRARIES =
lib_LTLIBRARIES += lib4ti2int32.la lib4ti2int64.la
+noinst_LTLIBRARIES = libglplpx.la
if HAVE_GMP_WITH_CXX
lib_LTLIBRARIES += lib4ti2gmp.la
endif
@@ -269,6 +270,8 @@ DISTCLEANFILES = $(WRAPPERSCRIPTS)
AM_LDFLAGS = -L../4ti2 -R$(libdir) -l4ti2common -no-undefined
+libglplpx_la_SOURCES = glplpx01.c
+
# 16 bit precision flags.
# 4ti2int16_LDADD = lib4ti2int16.la
# 4ti2int16_CPPFLAGS = -D_4ti2_INT16_
@@ -284,6 +287,7 @@ AM_LDFLAGS = -L../4ti2 -R$(libdir) -l4ti
lib4ti2int32_la_CPPFLAGS = -D_4ti2_INT32_
lib4ti2int32_la_CXXFLAGS = $(TRAPV) $(AM_CXXFLAGS)
lib4ti2int32_la_SOURCES = $(lib4ti2sources)
+lib4ti2int32_la_LIBADD = libglplpx.la
# 64 bit precision flags.
4ti2int64_LDADD = lib4ti2int64.la
@@ -293,6 +297,7 @@ lib4ti2int32_la_SOURCES = $(lib4ti2sourc
lib4ti2int64_la_CPPFLAGS = -D_4ti2_INT64_
lib4ti2int64_la_CXXFLAGS = $(TRAPV) $(AM_CXXFLAGS)
lib4ti2int64_la_SOURCES = $(lib4ti2sources)
+lib4ti2int64_la_LIBADD = libglplpx.la
# Arbitrary precision flags.
# 4ti2 uses GMP (GLPL), an arbitrary precision arithmetic library.
@@ -303,6 +308,7 @@ if HAVE_GMP_WITH_CXX
lib4ti2gmp_la_CPPFLAGS = -D_4ti2_GMP_
lib4ti2gmp_la_CPPFLAGS += $(GMP_CFLAGS)
lib4ti2gmp_la_SOURCES = $(lib4ti2sources)
+lib4ti2gmp_la_LIBADD = libglplpx.la
endif
EXTRA_DIST = script.template
Index: 4ti2-1.6/src/groebner/dmp.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/dmp.h
@@ -0,0 +1,63 @@
+/* dmp.h (dynamic memory pool) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef DMP_H
+#define DMP_H
+
+#include "stdc.h"
+
+typedef struct DMP DMP;
+
+#define dmp_debug _glp_dmp_debug
+extern int dmp_debug;
+/* debug mode flag */
+
+#define dmp_create_pool _glp_dmp_create_pool
+DMP *dmp_create_pool(void);
+/* create dynamic memory pool */
+
+#define dmp_talloc(pool, type) \
+ ((type *)dmp_get_atom(pool, sizeof(type)))
+
+#define dmp_get_atom _glp_dmp_get_atom
+void *dmp_get_atom(DMP *pool, int size);
+/* get free atom from dynamic memory pool */
+
+#define dmp_tfree(pool, atom) \
+ dmp_free_atom(pool, atom, sizeof(*(atom)))
+
+#define dmp_free_atom _glp_dmp_free_atom
+void dmp_free_atom(DMP *pool, void *atom, int size);
+/* return atom to dynamic memory pool */
+
+#define dmp_in_use _glp_dmp_in_use
+size_t dmp_in_use(DMP *pool);
+/* determine how many atoms are still in use */
+
+#define dmp_delete_pool _glp_dmp_delete_pool
+void dmp_delete_pool(DMP *pool);
+/* delete dynamic memory pool */
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/env.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/env.h
@@ -0,0 +1,207 @@
+/* env.h (GLPK environment) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef ENV_H
+#define ENV_H
+
+#include "stdc.h"
+
+typedef struct ENV ENV;
+typedef struct MBD MBD;
+
+#define SIZE_T_MAX (~(size_t)0)
+/* largest value of size_t type */
+
+#define TBUF_SIZE 4096
+/* terminal output buffer size, in bytes */
+
+/* enable/disable flag: */
+#define GLP_ON 1
+#define GLP_OFF 0
+
+struct ENV
+{ /* GLPK environment block */
+ char version[7+1];
+ /* version string returned by the routine glp_version */
+ ENV *self;
+ /* pointer to this block to check its validity */
+ /*--------------------------------------------------------------*/
+ /* terminal output */
+ char *term_buf; /* char term_buf[TBUF_SIZE]; */
+ /* terminal output buffer */
+ int term_out;
+ /* flag to enable/disable terminal output */
+ int (*term_hook)(void *info, const char *s);
+ /* user-defined routine to intercept terminal output */
+ void *term_info;
+ /* transit pointer (cookie) passed to the routine term_hook */
+ FILE *tee_file;
+ /* output stream used to copy terminal output */
+ /*--------------------------------------------------------------*/
+ /* error handling */
+ const char *err_file;
+ /* value of the __FILE__ macro passed to glp_error */
+ int err_line;
+ /* value of the __LINE__ macro passed to glp_error */
+ void (*err_hook)(void *info);
+ /* user-defined routine to intercept abnormal termination */
+ void *err_info;
+ /* transit pointer (cookie) passed to the routine err_hook */
+ /*--------------------------------------------------------------*/
+ /* dynamic memory allocation */
+ size_t mem_limit;
+ /* maximal amount of memory, in bytes, available for dynamic
+ allocation */
+ MBD *mem_ptr;
+ /* pointer to the linked list of allocated memory blocks */
+ int mem_count;
+ /* total number of currently allocated memory blocks */
+ int mem_cpeak;
+ /* peak value of mem_count */
+ size_t mem_total;
+ /* total amount of currently allocated memory, in bytes; it is
+ the sum of the size field over all memory block descriptors */
+ size_t mem_tpeak;
+ /* peak value of mem_total */
+ /*--------------------------------------------------------------*/
+ /* shared libraries support (optional) */
+ void *h_odbc;
+ /* handle to ODBC shared library */
+ void *h_mysql;
+ /* handle to MySQL shared library */
+};
+
+struct MBD
+{ /* memory block descriptor */
+ size_t size;
+ /* size of block, in bytes, including descriptor */
+ MBD *self;
+ /* pointer to this descriptor to check its validity */
+ MBD *prev;
+ /* pointer to previous memory block descriptor */
+ MBD *next;
+ /* pointer to next memory block descriptor */
+};
+
+#define get_env_ptr _glp_get_env_ptr
+ENV *get_env_ptr(void);
+/* retrieve pointer to environment block */
+
+#define tls_set_ptr _glp_tls_set_ptr
+void tls_set_ptr(void *ptr);
+/* store global pointer in TLS */
+
+#define tls_get_ptr _glp_tls_get_ptr
+void *tls_get_ptr(void);
+/* retrieve global pointer from TLS */
+
+#define xputs glp_puts
+void glp_puts(const char *s);
+/* write string on terminal */
+
+#define xprintf glp_printf
+void glp_printf(const char *fmt, ...);
+/* write formatted output on terminal */
+
+#define xvprintf glp_vprintf
+void glp_vprintf(const char *fmt, va_list arg);
+/* write formatted output on terminal */
+
+int glp_term_out(int flag);
+/* enable/disable terminal output */
+
+void glp_term_hook(int (*func)(void *info, const char *s), void *info);
+/* install hook to intercept terminal output */
+
+int glp_open_tee(const char *fname);
+/* start copying terminal output to text file */
+
+int glp_close_tee(void);
+/* stop copying terminal output to text file */
+
+#ifndef GLP_ERRFUNC_DEFINED
+#define GLP_ERRFUNC_DEFINED
+typedef void (*glp_errfunc)(const char *fmt, ...);
+#endif
+
+#define xerror glp_error_(__FILE__, __LINE__)
+glp_errfunc glp_error_(const char *file, int line);
+/* display fatal error message and terminate execution */
+
+#define xassert(expr) \
+ ((void)((expr) || (glp_assert_(#expr, __FILE__, __LINE__), 1)))
+void glp_assert_(const char *expr, const char *file, int line);
+/* check for logical condition */
+
+void glp_error_hook(void (*func)(void *info), void *info);
+/* install hook to intercept abnormal termination */
+
+#define xmalloc(size) glp_alloc(1, size)
+/* allocate memory block (obsolete) */
+
+#define xcalloc(n, size) glp_alloc(n, size)
+/* allocate memory block (obsolete) */
+
+#define xalloc(n, size) glp_alloc(n, size)
+#define talloc(n, type) ((type *)glp_alloc(n, sizeof(type)))
+void *glp_alloc(int n, int size);
+/* allocate memory block */
+
+#define xrealloc(ptr, n, size) glp_realloc(ptr, n, size)
+#define trealloc(ptr, n, type) ((type *)glp_realloc(ptr, n, \
+ sizeof(type)))
+void *glp_realloc(void *ptr, int n, int size);
+/* reallocate memory block */
+
+#define xfree(ptr) glp_free(ptr)
+#define tfree(ptr) glp_free(ptr)
+void glp_free(void *ptr);
+/* free memory block */
+
+void glp_mem_limit(int limit);
+/* set memory usage limit */
+
+void glp_mem_usage(int *count, int *cpeak, size_t *total,
+ size_t *tpeak);
+/* get memory usage information */
+
+#define xtime glp_time
+double glp_time(void);
+/* determine current universal time */
+
+#define xdifftime glp_difftime
+double glp_difftime(double t1, double t0);
+/* compute difference between two time values */
+
+#define xdlopen _glp_xdlopen
+void *xdlopen(const char *module);
+
+#define xdlsym _glp_xdlsym
+void *xdlsym(void *h, const char *symbol);
+
+#define xdlclose _glp_xdlclose
+void xdlclose(void *h);
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/glpapi.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/glpapi.h
@@ -0,0 +1,309 @@
+/* glpapi.h (application program interface) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+* 2009, 2010, 2011, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef GLPAPI_H
+#define GLPAPI_H
+
+#include "glpk.h"
+#include "glpavl.h"
+#include "glpbfd.h"
+#include "glplpx.h"
+#include "env.h"
+
+typedef struct GLPROW GLPROW;
+typedef struct GLPCOL GLPCOL;
+typedef struct GLPAIJ GLPAIJ;
+
+#define GLP_PROB_MAGIC 0xD7D9D6C2
+
+struct glp_prob
+{ /* LP/MIP problem object */
+ unsigned magic;
+ /* magic value used for debugging */
+ DMP *pool;
+ /* memory pool to store problem object components */
+ glp_tree *tree;
+ /* pointer to the search tree; set by the MIP solver when this
+ object is used in the tree as a core MIP object */
+ void *parms;
+ /* reserved for backward compatibility */
+ /*--------------------------------------------------------------*/
+ /* LP/MIP data */
+ char *name;
+ /* problem name (1 to 255 chars); NULL means no name is assigned
+ to the problem */
+ char *obj;
+ /* objective function name (1 to 255 chars); NULL means no name
+ is assigned to the objective function */
+ int dir;
+ /* optimization direction flag (objective "sense"):
+ GLP_MIN - minimization
+ GLP_MAX - maximization */
+ double c0;
+ /* constant term of the objective function ("shift") */
+ int m_max;
+ /* length of the array of rows (enlarged automatically) */
+ int n_max;
+ /* length of the array of columns (enlarged automatically) */
+ int m;
+ /* number of rows, 0 <= m <= m_max */
+ int n;
+ /* number of columns, 0 <= n <= n_max */
+ int nnz;
+ /* number of non-zero constraint coefficients, nnz >= 0 */
+ GLPROW **row; /* GLPROW *row[1+m_max]; */
+ /* row[i], 1 <= i <= m, is a pointer to i-th row */
+ GLPCOL **col; /* GLPCOL *col[1+n_max]; */
+ /* col[j], 1 <= j <= n, is a pointer to j-th column */
+ AVL *r_tree;
+ /* row index to find rows by their names; NULL means this index
+ does not exist */
+ AVL *c_tree;
+ /* column index to find columns by their names; NULL means this
+ index does not exist */
+ /*--------------------------------------------------------------*/
+ /* basis factorization (LP) */
+ int valid;
+ /* the factorization is valid only if this flag is set */
+ int *head; /* int head[1+m_max]; */
+ /* basis header (valid only if the factorization is valid);
+ head[i] = k is the ordinal number of auxiliary (1 <= k <= m)
+ or structural (m+1 <= k <= m+n) variable which corresponds to
+ i-th basic variable xB[i], 1 <= i <= m */
+ glp_bfcp *bfcp;
+ /* basis factorization control parameters; may be NULL */
+ BFD *bfd; /* BFD bfd[1:m,1:m]; */
+ /* basis factorization driver; may be NULL */
+ /*--------------------------------------------------------------*/
+ /* basic solution (LP) */
+ int pbs_stat;
+ /* primal basic solution status:
+ GLP_UNDEF - primal solution is undefined
+ GLP_FEAS - primal solution is feasible
+ GLP_INFEAS - primal solution is infeasible
+ GLP_NOFEAS - no primal feasible solution exists */
+ int dbs_stat;
+ /* dual basic solution status:
+ GLP_UNDEF - dual solution is undefined
+ GLP_FEAS - dual solution is feasible
+ GLP_INFEAS - dual solution is infeasible
+ GLP_NOFEAS - no dual feasible solution exists */
+ double obj_val;
+ /* objective function value */
+ int it_cnt;
+ /* simplex method iteration count; increased by one on performing
+ one simplex iteration */
+ int some;
+ /* ordinal number of some auxiliary or structural variable having
+ certain property, 0 <= some <= m+n */
+ /*--------------------------------------------------------------*/
+ /* interior-point solution (LP) */
+ int ipt_stat;
+ /* interior-point solution status:
+ GLP_UNDEF - interior solution is undefined
+ GLP_OPT - interior solution is optimal
+ GLP_INFEAS - interior solution is infeasible
+ GLP_NOFEAS - no feasible solution exists */
+ double ipt_obj;
+ /* objective function value */
+ /*--------------------------------------------------------------*/
+ /* integer solution (MIP) */
+ int mip_stat;
+ /* integer solution status:
+ GLP_UNDEF - integer solution is undefined
+ GLP_OPT - integer solution is optimal
+ GLP_FEAS - integer solution is feasible
+ GLP_NOFEAS - no integer solution exists */
+ double mip_obj;
+ /* objective function value */
+};
+
+struct GLPROW
+{ /* LP/MIP row (auxiliary variable) */
+ int i;
+ /* ordinal number (1 to m) assigned to this row */
+ char *name;
+ /* row name (1 to 255 chars); NULL means no name is assigned to
+ this row */
+ AVLNODE *node;
+ /* pointer to corresponding node in the row index; NULL means
+ that either the row index does not exist or this row has no
+ name assigned */
+#if 1 /* 20/IX-2008 */
+ int level;
+ unsigned char origin;
+ unsigned char klass;
+#endif
+ int type;
+ /* type of the auxiliary variable:
+ GLP_FR - free variable
+ GLP_LO - variable with lower bound
+ GLP_UP - variable with upper bound
+ GLP_DB - double-bounded variable
+ GLP_FX - fixed variable */
+ double lb; /* non-scaled */
+ /* lower bound; if the row has no lower bound, lb is zero */
+ double ub; /* non-scaled */
+ /* upper bound; if the row has no upper bound, ub is zero */
+ /* if the row type is GLP_FX, ub is equal to lb */
+ GLPAIJ *ptr; /* non-scaled */
+ /* pointer to doubly linked list of constraint coefficients which
+ are placed in this row */
+ double rii;
+ /* diagonal element r[i,i] of scaling matrix R for this row;
+ if the scaling is not used, r[i,i] is 1 */
+ int stat;
+ /* status of the auxiliary variable:
+ GLP_BS - basic variable
+ GLP_NL - non-basic variable on lower bound
+ GLP_NU - non-basic variable on upper bound
+ GLP_NF - non-basic free variable
+ GLP_NS - non-basic fixed variable */
+ int bind;
+ /* if the auxiliary variable is basic, head[bind] refers to this
+ row, otherwise, bind is 0; this attribute is valid only if the
+ basis factorization is valid */
+ double prim; /* non-scaled */
+ /* primal value of the auxiliary variable in basic solution */
+ double dual; /* non-scaled */
+ /* dual value of the auxiliary variable in basic solution */
+ double pval; /* non-scaled */
+ /* primal value of the auxiliary variable in interior solution */
+ double dval; /* non-scaled */
+ /* dual value of the auxiliary variable in interior solution */
+ double mipx; /* non-scaled */
+ /* primal value of the auxiliary variable in integer solution */
+};
+
+struct GLPCOL
+{ /* LP/MIP column (structural variable) */
+ int j;
+ /* ordinal number (1 to n) assigned to this column */
+ char *name;
+ /* column name (1 to 255 chars); NULL means no name is assigned
+ to this column */
+ AVLNODE *node;
+ /* pointer to corresponding node in the column index; NULL means
+ that either the column index does not exist or the column has
+ no name assigned */
+ int kind;
+ /* kind of the structural variable:
+ GLP_CV - continuous variable
+ GLP_IV - integer or binary variable */
+ int type;
+ /* type of the structural variable:
+ GLP_FR - free variable
+ GLP_LO - variable with lower bound
+ GLP_UP - variable with upper bound
+ GLP_DB - double-bounded variable
+ GLP_FX - fixed variable */
+ double lb; /* non-scaled */
+ /* lower bound; if the column has no lower bound, lb is zero */
+ double ub; /* non-scaled */
+ /* upper bound; if the column has no upper bound, ub is zero */
+ /* if the column type is GLP_FX, ub is equal to lb */
+ double coef; /* non-scaled */
+ /* objective coefficient at the structural variable */
+ GLPAIJ *ptr; /* non-scaled */
+ /* pointer to doubly linked list of constraint coefficients which
+ are placed in this column */
+ double sjj;
+ /* diagonal element s[j,j] of scaling matrix S for this column;
+ if the scaling is not used, s[j,j] is 1 */
+ int stat;
+ /* status of the structural variable:
+ GLP_BS - basic variable
+ GLP_NL - non-basic variable on lower bound
+ GLP_NU - non-basic variable on upper bound
+ GLP_NF - non-basic free variable
+ GLP_NS - non-basic fixed variable */
+ int bind;
+ /* if the structural variable is basic, head[bind] refers to
+ this column; otherwise, bind is 0; this attribute is valid only
+ if the basis factorization is valid */
+ double prim; /* non-scaled */
+ /* primal value of the structural variable in basic solution */
+ double dual; /* non-scaled */
+ /* dual value of the structural variable in basic solution */
+ double pval; /* non-scaled */
+ /* primal value of the structural variable in interior solution */
+ double dval; /* non-scaled */
+ /* dual value of the structural variable in interior solution */
+ double mipx; /* non-scaled */
+ /* primal value of the structural variable in integer solution */
+};
+
+struct GLPAIJ
+{ /* constraint coefficient a[i,j] */
+ GLPROW *row;
+ /* pointer to row, where this coefficient is placed */
+ GLPCOL *col;
+ /* pointer to column, where this coefficient is placed */
+ double val;
+ /* numeric (non-zero) value of this coefficient */
+ GLPAIJ *r_prev;
+ /* pointer to previous coefficient in the same row */
+ GLPAIJ *r_next;
+ /* pointer to next coefficient in the same row */
+ GLPAIJ *c_prev;
+ /* pointer to previous coefficient in the same column */
+ GLPAIJ *c_next;
+ /* pointer to next coefficient in the same column */
+};
+
+#define lpx_put_solution _glp_put_solution
+void lpx_put_solution(glp_prob *lp, int inval, const int *p_stat,
+ const int *d_stat, const double *obj_val, const int r_stat[],
+ const double r_prim[], const double r_dual[], const int c_stat[],
+ const double c_prim[], const double c_dual[]);
+/* store basic solution components */
+
+#define lpx_put_mip_soln _glp_put_mip_soln
+void lpx_put_mip_soln(LPX *lp, int i_stat, double row_mipx[],
+ double col_mipx[]);
+/* store mixed integer solution components */
+
+#if 1 /* 28/XI-2009 */
+int _glp_analyze_row(glp_prob *P, int len, const int ind[],
+ const double val[], int type, double rhs, double eps, int *_piv,
+ double *_x, double *_dx, double *_y, double *_dy, double *_dz);
+/* simulate one iteration of dual simplex method */
+#endif
+
+#if 1 /* 08/XII-2009 */
+void _glp_mpl_init_rand(glp_tran *tran, int seed);
+#endif
+
+#define glp_skpgen _glp_skpgen
+void glp_skpgen(int n, int r, int type, int v, int s, int a[],
+ int *b, int c[]);
+/* Pisinger's 0-1 single knapsack problem generator */
+
+#if 1 /* 28/V-2010 */
+int _glp_intopt1(glp_prob *P, const glp_iocp *parm);
+#endif
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/glpavl.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/glpavl.h
@@ -0,0 +1,123 @@
+/* glpavl.h (binary search tree) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+* 2009, 2010, 2011, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef GLPAVL_H
+#define GLPAVL_H
+
+#include "dmp.h"
+
+typedef struct AVL AVL;
+typedef struct AVLNODE AVLNODE;
+
+struct AVL
+{ /* AVL tree (Adelson-Velsky & Landis binary search tree) */
+ DMP *pool;
+ /* memory pool for allocating nodes */
+ AVLNODE *root;
+ /* pointer to the root node */
+ int (*fcmp)(void *info, const void *key1, const void *key2);
+ /* application-defined key comparison routine */
+ void *info;
+ /* transit pointer passed to the routine fcmp */
+ int size;
+ /* the tree size (the total number of nodes) */
+ int height;
+ /* the tree height */
+};
+
+struct AVLNODE
+{ /* node of AVL tree */
+ const void *key;
+ /* pointer to the node key (data structure for representing keys
+ is supplied by the application) */
+ int rank;
+ /* node rank = relative position of the node in its own subtree =
+ the number of nodes in the left subtree plus one */
+ int type;
+ /* reserved for the application specific information */
+ void *link;
+ /* reserved for the application specific information */
+ AVLNODE *up;
+ /* pointer to the parent node */
+ short int flag;
+ /* node flag:
+ 0 - this node is the left child of its parent (or this node is
+ the root of the tree and has no parent)
+ 1 - this node is the right child of its parent */
+ short int bal;
+ /* node balance = the difference between heights of the right and
+ left subtrees:
+ -1 - the left subtree is higher than the right one;
+ 0 - the left and right subtrees have the same height;
+ +1 - the left subtree is lower than the right one */
+ AVLNODE *left;
+ /* pointer to the root of the left subtree */
+ AVLNODE *right;
+ /* pointer to the root of the right subtree */
+};
+
+#define avl_create_tree _glp_avl_create_tree
+AVL *avl_create_tree(int (*fcmp)(void *info, const void *key1,
+ const void *key2), void *info);
+/* create AVL tree */
+
+#define avl_strcmp _glp_avl_strcmp
+int avl_strcmp(void *info, const void *key1, const void *key2);
+/* compare character string keys */
+
+#define avl_insert_node _glp_avl_insert_node
+AVLNODE *avl_insert_node(AVL *tree, const void *key);
+/* insert new node into AVL tree */
+
+#define avl_set_node_type _glp_avl_set_node_type
+void avl_set_node_type(AVLNODE *node, int type);
+/* assign the type field of specified node */
+
+#define avl_set_node_link _glp_avl_set_node_link
+void avl_set_node_link(AVLNODE *node, void *link);
+/* assign the link field of specified node */
+
+#define avl_find_node _glp_avl_find_node
+AVLNODE *avl_find_node(AVL *tree, const void *key);
+/* find node in AVL tree */
+
+#define avl_get_node_type _glp_avl_get_node_type
+int avl_get_node_type(AVLNODE *node);
+/* retrieve the type field of specified node */
+
+#define avl_get_node_link _glp_avl_get_node_link
+void *avl_get_node_link(AVLNODE *node);
+/* retrieve the link field of specified node */
+
+#define avl_delete_node _glp_avl_delete_node
+void avl_delete_node(AVL *tree, AVLNODE *node);
+/* delete specified node from AVL tree */
+
+#define avl_delete_tree _glp_avl_delete_tree
+void avl_delete_tree(AVL *tree);
+/* delete AVL tree */
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/glpbfd.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/glpbfd.h
@@ -0,0 +1,73 @@
+/* glpbfd.h (LP basis factorization driver) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+* 2009, 2010, 2011, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef GLPBFD_H
+#define GLPBFD_H
+
+typedef struct BFD BFD;
+
+/* return codes: */
+#define BFD_ESING 1 /* singular matrix */
+#define BFD_ECOND 2 /* ill-conditioned matrix */
+#define BFD_ECHECK 3 /* insufficient accuracy */
+#define BFD_ELIMIT 4 /* update limit reached */
+#define BFD_EROOM 5 /* SVA overflow */
+
+#define bfd_create_it _glp_bfd_create_it
+BFD *bfd_create_it(void);
+/* create LP basis factorization */
+
+#define bfd_set_parm _glp_bfd_set_parm
+void bfd_set_parm(BFD *bfd, const void *parm);
+/* change LP basis factorization control parameters */
+
+#define bfd_factorize _glp_bfd_factorize
+int bfd_factorize(BFD *bfd, int m, const int bh[], int (*col)
+ (void *info, int j, int ind[], double val[]), void *info);
+/* compute LP basis factorization */
+
+#define bfd_ftran _glp_bfd_ftran
+void bfd_ftran(BFD *bfd, double x[]);
+/* perform forward transformation (solve system B*x = b) */
+
+#define bfd_btran _glp_bfd_btran
+void bfd_btran(BFD *bfd, double x[]);
+/* perform backward transformation (solve system B'*x = b) */
+
+#define bfd_update_it _glp_bfd_update_it
+int bfd_update_it(BFD *bfd, int j, int bh, int len, const int ind[],
+ const double val[]);
+/* update LP basis factorization */
+
+#define bfd_get_count _glp_bfd_get_count
+int bfd_get_count(BFD *bfd);
+/* determine factorization update count */
+
+#define bfd_delete_it _glp_bfd_delete_it
+void bfd_delete_it(BFD *bfd);
+/* delete LP basis factorization */
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/glplpx.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/glplpx.h
@@ -0,0 +1,579 @@
+/* glplpx.h (obsolete API routines) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+* 2009, 2010, 2011, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef GLPLPX_H
+#define GLPLPX_H
+
+#define LPX glp_prob
+
+/* problem class: */
+#define LPX_LP 100 /* linear programming (LP) */
+#define LPX_MIP 101 /* mixed integer programming (MIP) */
+
+/* type of auxiliary/structural variable: */
+#define LPX_FR 110 /* free variable */
+#define LPX_LO 111 /* variable with lower bound */
+#define LPX_UP 112 /* variable with upper bound */
+#define LPX_DB 113 /* double-bounded variable */
+#define LPX_FX 114 /* fixed variable */
+
+/* optimization direction flag: */
+#define LPX_MIN 120 /* minimization */
+#define LPX_MAX 121 /* maximization */
+
+/* status of primal basic solution: */
+#define LPX_P_UNDEF 132 /* primal solution is undefined */
+#define LPX_P_FEAS 133 /* solution is primal feasible */
+#define LPX_P_INFEAS 134 /* solution is primal infeasible */
+#define LPX_P_NOFEAS 135 /* no primal feasible solution exists */
+
+/* status of dual basic solution: */
+#define LPX_D_UNDEF 136 /* dual solution is undefined */
+#define LPX_D_FEAS 137 /* solution is dual feasible */
+#define LPX_D_INFEAS 138 /* solution is dual infeasible */
+#define LPX_D_NOFEAS 139 /* no dual feasible solution exists */
+
+/* status of auxiliary/structural variable: */
+#define LPX_BS 140 /* basic variable */
+#define LPX_NL 141 /* non-basic variable on lower bound */
+#define LPX_NU 142 /* non-basic variable on upper bound */
+#define LPX_NF 143 /* non-basic free variable */
+#define LPX_NS 144 /* non-basic fixed variable */
+
+/* status of interior-point solution: */
+#define LPX_T_UNDEF 150 /* interior solution is undefined */
+#define LPX_T_OPT 151 /* interior solution is optimal */
+
+/* kind of structural variable: */
+#define LPX_CV 160 /* continuous variable */
+#define LPX_IV 161 /* integer variable */
+
+/* status of integer solution: */
+#define LPX_I_UNDEF 170 /* integer solution is undefined */
+#define LPX_I_OPT 171 /* integer solution is optimal */
+#define LPX_I_FEAS 172 /* integer solution is feasible */
+#define LPX_I_NOFEAS 173 /* no integer solution exists */
+
+/* status codes reported by the routine lpx_get_status: */
+#define LPX_OPT 180 /* optimal */
+#define LPX_FEAS 181 /* feasible */
+#define LPX_INFEAS 182 /* infeasible */
+#define LPX_NOFEAS 183 /* no feasible */
+#define LPX_UNBND 184 /* unbounded */
+#define LPX_UNDEF 185 /* undefined */
+
+/* exit codes returned by solver routines: */
+#define LPX_E_OK 200 /* success */
+#define LPX_E_EMPTY 201 /* empty problem */
+#define LPX_E_BADB 202 /* invalid initial basis */
+#define LPX_E_INFEAS 203 /* infeasible initial solution */
+#define LPX_E_FAULT 204 /* unable to start the search */
+#define LPX_E_OBJLL 205 /* objective lower limit reached */
+#define LPX_E_OBJUL 206 /* objective upper limit reached */
+#define LPX_E_ITLIM 207 /* iterations limit exhausted */
+#define LPX_E_TMLIM 208 /* time limit exhausted */
+#define LPX_E_NOFEAS 209 /* no feasible solution */
+#define LPX_E_INSTAB 210 /* numerical instability */
+#define LPX_E_SING 211 /* problems with basis matrix */
+#define LPX_E_NOCONV 212 /* no convergence (interior) */
+#define LPX_E_NOPFS 213 /* no primal feas. sol. (LP presolver) */
+#define LPX_E_NODFS 214 /* no dual feas. sol. (LP presolver) */
+#define LPX_E_MIPGAP 215 /* relative mip gap tolerance reached */
+
+/* control parameter identifiers: */
+#define LPX_K_MSGLEV 300 /* lp->msg_lev */
+#define LPX_K_SCALE 301 /* lp->scale */
+#define LPX_K_DUAL 302 /* lp->dual */
+#define LPX_K_PRICE 303 /* lp->price */
+#define LPX_K_RELAX 304 /* lp->relax */
+#define LPX_K_TOLBND 305 /* lp->tol_bnd */
+#define LPX_K_TOLDJ 306 /* lp->tol_dj */
+#define LPX_K_TOLPIV 307 /* lp->tol_piv */
+#define LPX_K_ROUND 308 /* lp->round */
+#define LPX_K_OBJLL 309 /* lp->obj_ll */
+#define LPX_K_OBJUL 310 /* lp->obj_ul */
+#define LPX_K_ITLIM 311 /* lp->it_lim */
+#define LPX_K_ITCNT 312 /* lp->it_cnt */
+#define LPX_K_TMLIM 313 /* lp->tm_lim */
+#define LPX_K_OUTFRQ 314 /* lp->out_frq */
+#define LPX_K_OUTDLY 315 /* lp->out_dly */
+#define LPX_K_BRANCH 316 /* lp->branch */
+#define LPX_K_BTRACK 317 /* lp->btrack */
+#define LPX_K_TOLINT 318 /* lp->tol_int */
+#define LPX_K_TOLOBJ 319 /* lp->tol_obj */
+#define LPX_K_MPSINFO 320 /* lp->mps_info */
+#define LPX_K_MPSOBJ 321 /* lp->mps_obj */
+#define LPX_K_MPSORIG 322 /* lp->mps_orig */
+#define LPX_K_MPSWIDE 323 /* lp->mps_wide */
+#define LPX_K_MPSFREE 324 /* lp->mps_free */
+#define LPX_K_MPSSKIP 325 /* lp->mps_skip */
+#define LPX_K_LPTORIG 326 /* lp->lpt_orig */
+#define LPX_K_PRESOL 327 /* lp->presol */
+#define LPX_K_BINARIZE 328 /* lp->binarize */
+#define LPX_K_USECUTS 329 /* lp->use_cuts */
+#define LPX_K_BFTYPE 330 /* lp->bfcp->type */
+#define LPX_K_MIPGAP 331 /* lp->mip_gap */
+
+#define LPX_C_COVER 0x01 /* mixed cover cuts */
+#define LPX_C_CLIQUE 0x02 /* clique cuts */
+#define LPX_C_GOMORY 0x04 /* Gomory's mixed integer cuts */
+#define LPX_C_MIR 0x08 /* mixed integer rounding cuts */
+#define LPX_C_ALL 0xFF /* all cuts */
+
+typedef struct
+{ /* this structure contains results reported by the routines which
+ checks Karush-Kuhn-Tucker conditions (for details see comments
+ to those routines) */
+ /*--------------------------------------------------------------*/
+ /* xR - A * xS = 0 (KKT.PE) */
+ double pe_ae_max;
+ /* largest absolute error */
+ int pe_ae_row;
+ /* number of row with largest absolute error */
+ double pe_re_max;
+ /* largest relative error */
+ int pe_re_row;
+ /* number of row with largest relative error */
+ int pe_quality;
+ /* quality of primal solution:
+ 'H' - high
+ 'M' - medium
+ 'L' - low
+ '?' - primal solution is wrong */
+ /*--------------------------------------------------------------*/
+ /* l[k] <= x[k] <= u[k] (KKT.PB) */
+ double pb_ae_max;
+ /* largest absolute error */
+ int pb_ae_ind;
+ /* number of variable with largest absolute error */
+ double pb_re_max;
+ /* largest relative error */
+ int pb_re_ind;
+ /* number of variable with largest relative error */
+ int pb_quality;
+ /* quality of primal feasibility:
+ 'H' - high
+ 'M' - medium
+ 'L' - low
+ '?' - primal solution is infeasible */
+ /*--------------------------------------------------------------*/
+ /* A' * (dR - cR) + (dS - cS) = 0 (KKT.DE) */
+ double de_ae_max;
+ /* largest absolute error */
+ int de_ae_col;
+ /* number of column with largest absolute error */
+ double de_re_max;
+ /* largest relative error */
+ int de_re_col;
+ /* number of column with largest relative error */
+ int de_quality;
+ /* quality of dual solution:
+ 'H' - high
+ 'M' - medium
+ 'L' - low
+ '?' - dual solution is wrong */
+ /*--------------------------------------------------------------*/
+ /* d[k] >= 0 or d[k] <= 0 (KKT.DB) */
+ double db_ae_max;
+ /* largest absolute error */
+ int db_ae_ind;
+ /* number of variable with largest absolute error */
+ double db_re_max;
+ /* largest relative error */
+ int db_re_ind;
+ /* number of variable with largest relative error */
+ int db_quality;
+ /* quality of dual feasibility:
+ 'H' - high
+ 'M' - medium
+ 'L' - low
+ '?' - dual solution is infeasible */
+ /*--------------------------------------------------------------*/
+ /* (x[k] - bound of x[k]) * d[k] = 0 (KKT.CS) */
+ double cs_ae_max;
+ /* largest absolute error */
+ int cs_ae_ind;
+ /* number of variable with largest absolute error */
+ double cs_re_max;
+ /* largest relative error */
+ int cs_re_ind;
+ /* number of variable with largest relative error */
+ int cs_quality;
+ /* quality of complementary slackness:
+ 'H' - high
+ 'M' - medium
+ 'L' - low
+ '?' - primal and dual solutions are not complementary */
+} LPXKKT;
+
+LPX *lpx_create_prob(void);
+/* create problem object */
+
+void lpx_set_prob_name(LPX *lp, const char *name);
+/* assign (change) problem name */
+
+void lpx_set_obj_name(LPX *lp, const char *name);
+/* assign (change) objective function name */
+
+void lpx_set_obj_dir(LPX *lp, int dir);
+/* set (change) optimization direction flag */
+
+int lpx_add_rows(LPX *lp, int nrs);
+/* add new rows to problem object */
+
+int lpx_add_cols(LPX *lp, int ncs);
+/* add new columns to problem object */
+
+void lpx_set_row_name(LPX *lp, int i, const char *name);
+/* assign (change) row name */
+
+void lpx_set_col_name(LPX *lp, int j, const char *name);
+/* assign (change) column name */
+
+void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub);
+/* set (change) row bounds */
+
+void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub);
+/* set (change) column bounds */
+
+void lpx_set_obj_coef(glp_prob *lp, int j, double coef);
+/* set (change) obj. coefficient or constant term */
+
+void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
+ const double val[]);
+/* set (replace) row of the constraint matrix */
+
+void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
+ const double val[]);
+/* set (replace) column of the constraint matrix */
+
+void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
+ const double ar[]);
+/* load (replace) the whole constraint matrix */
+
+void lpx_del_rows(LPX *lp, int nrs, const int num[]);
+/* delete specified rows from problem object */
+
+void lpx_del_cols(LPX *lp, int ncs, const int num[]);
+/* delete specified columns from problem object */
+
+void lpx_delete_prob(LPX *lp);
+/* delete problem object */
+
+const char *lpx_get_prob_name(LPX *lp);
+/* retrieve problem name */
+
+const char *lpx_get_obj_name(LPX *lp);
+/* retrieve objective function name */
+
+int lpx_get_obj_dir(LPX *lp);
+/* retrieve optimization direction flag */
+
+int lpx_get_num_rows(LPX *lp);
+/* retrieve number of rows */
+
+int lpx_get_num_cols(LPX *lp);
+/* retrieve number of columns */
+
+const char *lpx_get_row_name(LPX *lp, int i);
+/* retrieve row name */
+
+const char *lpx_get_col_name(LPX *lp, int j);
+/* retrieve column name */
+
+int lpx_get_row_type(LPX *lp, int i);
+/* retrieve row type */
+
+double lpx_get_row_lb(LPX *lp, int i);
+/* retrieve row lower bound */
+
+double lpx_get_row_ub(LPX *lp, int i);
+/* retrieve row upper bound */
+
+void lpx_get_row_bnds(LPX *lp, int i, int *typx, double *lb,
+ double *ub);
+/* retrieve row bounds */
+
+int lpx_get_col_type(LPX *lp, int j);
+/* retrieve column type */
+
+double lpx_get_col_lb(LPX *lp, int j);
+/* retrieve column lower bound */
+
+double lpx_get_col_ub(LPX *lp, int j);
+/* retrieve column upper bound */
+
+void lpx_get_col_bnds(LPX *lp, int j, int *typx, double *lb,
+ double *ub);
+/* retrieve column bounds */
+
+double lpx_get_obj_coef(LPX *lp, int j);
+/* retrieve obj. coefficient or constant term */
+
+int lpx_get_num_nz(LPX *lp);
+/* retrieve number of constraint coefficients */
+
+int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[]);
+/* retrieve row of the constraint matrix */
+
+int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[]);
+/* retrieve column of the constraint matrix */
+
+void lpx_create_index(LPX *lp);
+/* create the name index */
+
+int lpx_find_row(LPX *lp, const char *name);
+/* find row by its name */
+
+int lpx_find_col(LPX *lp, const char *name);
+/* find column by its name */
+
+void lpx_delete_index(LPX *lp);
+/* delete the name index */
+
+void lpx_scale_prob(LPX *lp);
+/* scale problem data */
+
+void lpx_unscale_prob(LPX *lp);
+/* unscale problem data */
+
+void lpx_set_row_stat(LPX *lp, int i, int stat);
+/* set (change) row status */
+
+void lpx_set_col_stat(LPX *lp, int j, int stat);
+/* set (change) column status */
+
+void lpx_std_basis(LPX *lp);
+/* construct standard initial LP basis */
+
+void lpx_adv_basis(LPX *lp);
+/* construct advanced initial LP basis */
+
+void lpx_cpx_basis(LPX *lp);
+/* construct Bixby's initial LP basis */
+
+int lpx_simplex(LPX *lp);
+/* easy-to-use driver to the simplex method */
+
+int lpx_exact(LPX *lp);
+/* easy-to-use driver to the exact simplex method */
+
+int lpx_get_status(LPX *lp);
+/* retrieve generic status of basic solution */
+
+int lpx_get_prim_stat(LPX *lp);
+/* retrieve primal status of basic solution */
+
+int lpx_get_dual_stat(LPX *lp);
+/* retrieve dual status of basic solution */
+
+double lpx_get_obj_val(LPX *lp);
+/* retrieve objective value (basic solution) */
+
+int lpx_get_row_stat(LPX *lp, int i);
+/* retrieve row status (basic solution) */
+
+double lpx_get_row_prim(LPX *lp, int i);
+/* retrieve row primal value (basic solution) */
+
+double lpx_get_row_dual(LPX *lp, int i);
+/* retrieve row dual value (basic solution) */
+
+void lpx_get_row_info(LPX *lp, int i, int *tagx, double *vx,
+ double *dx);
+/* obtain row solution information */
+
+int lpx_get_col_stat(LPX *lp, int j);
+/* retrieve column status (basic solution) */
+
+double lpx_get_col_prim(LPX *lp, int j);
+/* retrieve column primal value (basic solution) */
+
+double lpx_get_col_dual(glp_prob *lp, int j);
+/* retrieve column dual value (basic solution) */
+
+void lpx_get_col_info(LPX *lp, int j, int *tagx, double *vx,
+ double *dx);
+/* obtain column solution information (obsolete) */
+
+int lpx_get_ray_info(LPX *lp);
+/* determine what causes primal unboundness */
+
+void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt);
+/* check Karush-Kuhn-Tucker conditions */
+
+int lpx_warm_up(LPX *lp);
+/* "warm up" LP basis */
+
+int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[]);
+/* compute row of the simplex table */
+
+int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[]);
+/* compute column of the simplex table */
+
+int lpx_transform_row(LPX *lp, int len, int ind[], double val[]);
+/* transform explicitly specified row */
+
+int lpx_transform_col(LPX *lp, int len, int ind[], double val[]);
+/* transform explicitly specified column */
+
+int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
+ const double val[], int how, double tol);
+/* perform primal ratio test */
+
+int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
+ const double val[], int how, double tol);
+/* perform dual ratio test */
+
+int lpx_interior(LPX *lp);
+/* easy-to-use driver to the interior point method */
+
+int lpx_ipt_status(LPX *lp);
+/* retrieve status of interior-point solution */
+
+double lpx_ipt_obj_val(LPX *lp);
+/* retrieve objective value (interior point) */
+
+double lpx_ipt_row_prim(LPX *lp, int i);
+/* retrieve row primal value (interior point) */
+
+double lpx_ipt_row_dual(LPX *lp, int i);
+/* retrieve row dual value (interior point) */
+
+double lpx_ipt_col_prim(LPX *lp, int j);
+/* retrieve column primal value (interior point) */
+
+double lpx_ipt_col_dual(LPX *lp, int j);
+/* retrieve column dual value (interior point) */
+
+void lpx_set_class(LPX *lp, int klass);
+/* set problem class */
+
+int lpx_get_class(LPX *lp);
+/* determine problem klass */
+
+void lpx_set_col_kind(LPX *lp, int j, int kind);
+/* set (change) column kind */
+
+int lpx_get_col_kind(LPX *lp, int j);
+/* retrieve column kind */
+
+int lpx_get_num_int(LPX *lp);
+/* retrieve number of integer columns */
+
+int lpx_get_num_bin(LPX *lp);
+/* retrieve number of binary columns */
+
+int lpx_integer(LPX *lp);
+/* easy-to-use driver to the branch-and-bound method */
+
+int lpx_intopt(LPX *lp);
+/* easy-to-use driver to the branch-and-bound method */
+
+int lpx_mip_status(LPX *lp);
+/* retrieve status of MIP solution */
+
+double lpx_mip_obj_val(LPX *lp);
+/* retrieve objective value (MIP solution) */
+
+double lpx_mip_row_val(LPX *lp, int i);
+/* retrieve row value (MIP solution) */
+
+double lpx_mip_col_val(LPX *lp, int j);
+/* retrieve column value (MIP solution) */
+
+void lpx_check_int(LPX *lp, LPXKKT *kkt);
+/* check integer feasibility conditions */
+
+void lpx_reset_parms(LPX *lp);
+/* reset control parameters to default values */
+
+void lpx_set_int_parm(LPX *lp, int parm, int val);
+/* set (change) integer control parameter */
+
+int lpx_get_int_parm(LPX *lp, int parm);
+/* query integer control parameter */
+
+void lpx_set_real_parm(LPX *lp, int parm, double val);
+/* set (change) real control parameter */
+
+double lpx_get_real_parm(LPX *lp, int parm);
+/* query real control parameter */
+
+LPX *lpx_read_mps(const char *fname);
+/* read problem data in fixed MPS format */
+
+int lpx_write_mps(LPX *lp, const char *fname);
+/* write problem data in fixed MPS format */
+
+int lpx_read_bas(LPX *lp, const char *fname);
+/* read LP basis in fixed MPS format */
+
+int lpx_write_bas(LPX *lp, const char *fname);
+/* write LP basis in fixed MPS format */
+
+LPX *lpx_read_freemps(const char *fname);
+/* read problem data in free MPS format */
+
+int lpx_write_freemps(LPX *lp, const char *fname);
+/* write problem data in free MPS format */
+
+LPX *lpx_read_cpxlp(const char *fname);
+/* read problem data in CPLEX LP format */
+
+int lpx_write_cpxlp(LPX *lp, const char *fname);
+/* write problem data in CPLEX LP format */
+
+LPX *lpx_read_model(const char *model, const char *data,
+ const char *output);
+/* read LP/MIP model written in GNU MathProg language */
+
+int lpx_print_prob(LPX *lp, const char *fname);
+/* write problem data in plain text format */
+
+int lpx_print_sol(LPX *lp, const char *fname);
+/* write LP problem solution in printable format */
+
+int lpx_print_sens_bnds(LPX *lp, const char *fname);
+/* write bounds sensitivity information */
+
+int lpx_print_ips(LPX *lp, const char *fname);
+/* write interior point solution in printable format */
+
+int lpx_print_mip(LPX *lp, const char *fname);
+/* write MIP problem solution in printable format */
+
+int lpx_is_b_avail(LPX *lp);
+/* check if LP basis is available */
+
+int lpx_write_pb(LPX *lp, const char *fname, int normalized,
+ int binarize);
+/* write problem data in (normalized) OPB format */
+
+int lpx_main(int argc, const char *argv[]);
+/* stand-alone LP/MIP solver */
+
+#endif
+
+/* eof */
Index: 4ti2-1.6/src/groebner/glplpx01.c
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/glplpx01.c
@@ -0,0 +1,1542 @@
+/* glplpx01.c (obsolete API routines) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+* 2009, 2010, 2011, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#include "glpapi.h"
+
+struct LPXCPS
+{ /* control parameters and statistics */
+ int msg_lev;
+ /* level of messages output by the solver:
+ 0 - no output
+ 1 - error messages only
+ 2 - normal output
+ 3 - full output (includes informational messages) */
+ int scale;
+ /* scaling option:
+ 0 - no scaling
+ 1 - equilibration scaling
+ 2 - geometric mean scaling
+ 3 - geometric mean scaling, then equilibration scaling */
+ int dual;
+ /* dual simplex option:
+ 0 - use primal simplex
+ 1 - use dual simplex */
+ int price;
+ /* pricing option (for both primal and dual simplex):
+ 0 - textbook pricing
+ 1 - steepest edge pricing */
+ double relax;
+ /* relaxation parameter used in the ratio test; if it is zero,
+ the textbook ratio test is used; if it is non-zero (should be
+ positive), Harris' two-pass ratio test is used; in the latter
+ case on the first pass basic variables (in the case of primal
+ simplex) or reduced costs of non-basic variables (in the case
+ of dual simplex) are allowed to slightly violate their bounds,
+ but not more than (relax * tol_bnd) or (relax * tol_dj) (thus,
+ relax is a percentage of tol_bnd or tol_dj) */
+ double tol_bnd;
+ /* relative tolerance used to check if the current basic solution
+ is primal feasible */
+ double tol_dj;
+ /* absolute tolerance used to check if the current basic solution
+ is dual feasible */
+ double tol_piv;
+ /* relative tolerance used to choose eligible pivotal elements of
+ the simplex table in the ratio test */
+ int round;
+ /* solution rounding option:
+ 0 - report all computed values and reduced costs "as is"
+ 1 - if possible (allowed by the tolerances), replace computed
+ values and reduced costs which are close to zero by exact
+ zeros */
+ double obj_ll;
+ /* lower limit of the objective function; if on the phase II the
+ objective function reaches this limit and continues decreasing,
+ the solver stops the search */
+ double obj_ul;
+ /* upper limit of the objective function; if on the phase II the
+ objective function reaches this limit and continues increasing,
+ the solver stops the search */
+ int it_lim;
+ /* simplex iterations limit; if this value is positive, it is
+ decreased by one each time when one simplex iteration has been
+ performed, and reaching zero value signals the solver to stop
+ the search; negative value means no iterations limit */
+ double tm_lim;
+ /* searching time limit, in seconds; if this value is positive,
+ it is decreased each time when one simplex iteration has been
+ performed by the amount of time spent for the iteration, and
+ reaching zero value signals the solver to stop the search;
+ negative value means no time limit */
+ int out_frq;
+ /* output frequency, in iterations; this parameter specifies how
+ frequently the solver sends information about the solution to
+ the standard output */
+ double out_dly;
+ /* output delay, in seconds; this parameter specifies how long
+ the solver should delay sending information about the solution
+ to the standard output; zero value means no delay */
+ int branch; /* MIP */
+ /* branching heuristic:
+ 0 - branch on first variable
+ 1 - branch on last variable
+ 2 - branch using heuristic by Driebeck and Tomlin
+ 3 - branch on most fractional variable */
+ int btrack; /* MIP */
+ /* backtracking heuristic:
+ 0 - select most recent node (depth first search)
+ 1 - select earliest node (breadth first search)
+ 2 - select node using the best projection heuristic
+ 3 - select node with best local bound */
+ double tol_int; /* MIP */
+ /* absolute tolerance used to check if the current basic solution
+ is integer feasible */
+ double tol_obj; /* MIP */
+ /* relative tolerance used to check if the value of the objective
+ function is not better than in the best known integer feasible
+ solution */
+ int mps_info; /* lpx_write_mps */
+ /* if this flag is set, the routine lpx_write_mps outputs several
+ comment cards that contains some information about the problem;
+ otherwise the routine outputs no comment cards */
+ int mps_obj; /* lpx_write_mps */
+ /* this parameter tells the routine lpx_write_mps how to output
+ the objective function row:
+ 0 - never output objective function row
+ 1 - always output objective function row
+ 2 - output objective function row if and only if the problem
+ has no free rows */
+ int mps_orig; /* lpx_write_mps */
+ /* if this flag is set, the routine lpx_write_mps uses original
+ row and column symbolic names; otherwise the routine generates
+ plain names using ordinal numbers of rows and columns */
+ int mps_wide; /* lpx_write_mps */
+ /* if this flag is set, the routine lpx_write_mps uses all data
+ fields; otherwise the routine keeps fields 5 and 6 empty */
+ int mps_free; /* lpx_write_mps */
+ /* if this flag is set, the routine lpx_write_mps omits column
+ and vector names everytime if possible (free style); otherwise
+ the routine never omits these names (pedantic style) */
+ int mps_skip; /* lpx_write_mps */
+ /* if this flag is set, the routine lpx_write_mps skips empty
+ columns (i.e. which has no constraint coefficients); otherwise
+ the routine outputs all columns */
+ int lpt_orig; /* lpx_write_lpt */
+ /* if this flag is set, the routine lpx_write_lpt uses original
+ row and column symbolic names; otherwise the routine generates
+ plain names using ordinal numbers of rows and columns */
+ int presol; /* lpx_simplex */
+ /* LP presolver option:
+ 0 - do not use LP presolver
+ 1 - use LP presolver */
+ int binarize; /* lpx_intopt */
+ /* if this flag is set, the routine lpx_intopt replaces integer
+ columns by binary ones */
+ int use_cuts; /* lpx_intopt */
+ /* if this flag is set, the routine lpx_intopt tries generating
+ cutting planes:
+ LPX_C_COVER - mixed cover cuts
+ LPX_C_CLIQUE - clique cuts
+ LPX_C_GOMORY - Gomory's mixed integer cuts
+ LPX_C_ALL - all cuts */
+ double mip_gap; /* MIP */
+ /* relative MIP gap tolerance */
+};
+
+LPX *lpx_create_prob(void)
+{ /* create problem object */
+ return glp_create_prob();
+}
+
+void lpx_set_prob_name(LPX *lp, const char *name)
+{ /* assign (change) problem name */
+ glp_set_prob_name(lp, name);
+ return;
+}
+
+void lpx_set_obj_name(LPX *lp, const char *name)
+{ /* assign (change) objective function name */
+ glp_set_obj_name(lp, name);
+ return;
+}
+
+void lpx_set_obj_dir(LPX *lp, int dir)
+{ /* set (change) optimization direction flag */
+ glp_set_obj_dir(lp, dir - LPX_MIN + GLP_MIN);
+ return;
+}
+
+int lpx_add_rows(LPX *lp, int nrs)
+{ /* add new rows to problem object */
+ return glp_add_rows(lp, nrs);
+}
+
+int lpx_add_cols(LPX *lp, int ncs)
+{ /* add new columns to problem object */
+ return glp_add_cols(lp, ncs);
+}
+
+void lpx_set_row_name(LPX *lp, int i, const char *name)
+{ /* assign (change) row name */
+ glp_set_row_name(lp, i, name);
+ return;
+}
+
+void lpx_set_col_name(LPX *lp, int j, const char *name)
+{ /* assign (change) column name */
+ glp_set_col_name(lp, j, name);
+ return;
+}
+
+void lpx_set_row_bnds(LPX *lp, int i, int type, double lb, double ub)
+{ /* set (change) row bounds */
+ glp_set_row_bnds(lp, i, type - LPX_FR + GLP_FR, lb, ub);
+ return;
+}
+
+void lpx_set_col_bnds(LPX *lp, int j, int type, double lb, double ub)
+{ /* set (change) column bounds */
+ glp_set_col_bnds(lp, j, type - LPX_FR + GLP_FR, lb, ub);
+ return;
+}
+
+void lpx_set_obj_coef(glp_prob *lp, int j, double coef)
+{ /* set (change) obj. coefficient or constant term */
+ glp_set_obj_coef(lp, j, coef);
+ return;
+}
+
+void lpx_set_mat_row(LPX *lp, int i, int len, const int ind[],
+ const double val[])
+{ /* set (replace) row of the constraint matrix */
+ glp_set_mat_row(lp, i, len, ind, val);
+ return;
+}
+
+void lpx_set_mat_col(LPX *lp, int j, int len, const int ind[],
+ const double val[])
+{ /* set (replace) column of the constraint matrix */
+ glp_set_mat_col(lp, j, len, ind, val);
+ return;
+}
+
+void lpx_load_matrix(LPX *lp, int ne, const int ia[], const int ja[],
+ const double ar[])
+{ /* load (replace) the whole constraint matrix */
+ glp_load_matrix(lp, ne, ia, ja, ar);
+ return;
+}
+
+void lpx_del_rows(LPX *lp, int nrs, const int num[])
+{ /* delete specified rows from problem object */
+ glp_del_rows(lp, nrs, num);
+ return;
+}
+
+void lpx_del_cols(LPX *lp, int ncs, const int num[])
+{ /* delete specified columns from problem object */
+ glp_del_cols(lp, ncs, num);
+ return;
+}
+
+void lpx_delete_prob(LPX *lp)
+{ /* delete problem object */
+ glp_delete_prob(lp);
+ return;
+}
+
+const char *lpx_get_prob_name(LPX *lp)
+{ /* retrieve problem name */
+ return glp_get_prob_name(lp);
+}
+
+const char *lpx_get_obj_name(LPX *lp)
+{ /* retrieve objective function name */
+ return glp_get_obj_name(lp);
+}
+
+int lpx_get_obj_dir(LPX *lp)
+{ /* retrieve optimization direction flag */
+ return glp_get_obj_dir(lp) - GLP_MIN + LPX_MIN;
+}
+
+int lpx_get_num_rows(LPX *lp)
+{ /* retrieve number of rows */
+ return glp_get_num_rows(lp);
+}
+
+int lpx_get_num_cols(LPX *lp)
+{ /* retrieve number of columns */
+ return glp_get_num_cols(lp);
+}
+
+const char *lpx_get_row_name(LPX *lp, int i)
+{ /* retrieve row name */
+ return glp_get_row_name(lp, i);
+}
+
+const char *lpx_get_col_name(LPX *lp, int j)
+{ /* retrieve column name */
+ return glp_get_col_name(lp, j);
+}
+
+int lpx_get_row_type(LPX *lp, int i)
+{ /* retrieve row type */
+ return glp_get_row_type(lp, i) - GLP_FR + LPX_FR;
+}
+
+double lpx_get_row_lb(glp_prob *lp, int i)
+{ /* retrieve row lower bound */
+ double lb;
+ lb = glp_get_row_lb(lp, i);
+ if (lb == -DBL_MAX) lb = 0.0;
+ return lb;
+}
+
+double lpx_get_row_ub(glp_prob *lp, int i)
+{ /* retrieve row upper bound */
+ double ub;
+ ub = glp_get_row_ub(lp, i);
+ if (ub == +DBL_MAX) ub = 0.0;
+ return ub;
+}
+
+void lpx_get_row_bnds(glp_prob *lp, int i, int *typx, double *lb,
+ double *ub)
+{ /* retrieve row bounds */
+ if (typx != NULL) *typx = lpx_get_row_type(lp, i);
+ if (lb != NULL) *lb = lpx_get_row_lb(lp, i);
+ if (ub != NULL) *ub = lpx_get_row_ub(lp, i);
+ return;
+}
+
+int lpx_get_col_type(LPX *lp, int j)
+{ /* retrieve column type */
+ return glp_get_col_type(lp, j) - GLP_FR + LPX_FR;
+}
+
+double lpx_get_col_lb(glp_prob *lp, int j)
+{ /* retrieve column lower bound */
+ double lb;
+ lb = glp_get_col_lb(lp, j);
+ if (lb == -DBL_MAX) lb = 0.0;
+ return lb;
+}
+
+double lpx_get_col_ub(glp_prob *lp, int j)
+{ /* retrieve column upper bound */
+ double ub;
+ ub = glp_get_col_ub(lp, j);
+ if (ub == +DBL_MAX) ub = 0.0;
+ return ub;
+}
+
+void lpx_get_col_bnds(glp_prob *lp, int j, int *typx, double *lb,
+ double *ub)
+{ /* retrieve column bounds */
+ if (typx != NULL) *typx = lpx_get_col_type(lp, j);
+ if (lb != NULL) *lb = lpx_get_col_lb(lp, j);
+ if (ub != NULL) *ub = lpx_get_col_ub(lp, j);
+ return;
+}
+
+double lpx_get_obj_coef(LPX *lp, int j)
+{ /* retrieve obj. coefficient or constant term */
+ return glp_get_obj_coef(lp, j);
+}
+
+int lpx_get_num_nz(LPX *lp)
+{ /* retrieve number of constraint coefficients */
+ return glp_get_num_nz(lp);
+}
+
+int lpx_get_mat_row(LPX *lp, int i, int ind[], double val[])
+{ /* retrieve row of the constraint matrix */
+ return glp_get_mat_row(lp, i, ind, val);
+}
+
+int lpx_get_mat_col(LPX *lp, int j, int ind[], double val[])
+{ /* retrieve column of the constraint matrix */
+ return glp_get_mat_col(lp, j, ind, val);
+}
+
+void lpx_create_index(LPX *lp)
+{ /* create the name index */
+ glp_create_index(lp);
+ return;
+}
+
+int lpx_find_row(LPX *lp, const char *name)
+{ /* find row by its name */
+ return glp_find_row(lp, name);
+}
+
+int lpx_find_col(LPX *lp, const char *name)
+{ /* find column by its name */
+ return glp_find_col(lp, name);
+}
+
+void lpx_delete_index(LPX *lp)
+{ /* delete the name index */
+ glp_delete_index(lp);
+ return;
+}
+
+void lpx_scale_prob(LPX *lp)
+{ /* scale problem data */
+ switch (lpx_get_int_parm(lp, LPX_K_SCALE))
+ { case 0:
+ /* no scaling */
+ glp_unscale_prob(lp);
+ break;
+ case 1:
+ /* equilibration scaling */
+ glp_scale_prob(lp, GLP_SF_EQ);
+ break;
+ case 2:
+ /* geometric mean scaling */
+ glp_scale_prob(lp, GLP_SF_GM);
+ break;
+ case 3:
+ /* geometric mean scaling, then equilibration scaling */
+ glp_scale_prob(lp, GLP_SF_GM | GLP_SF_EQ);
+ break;
+ default:
+ xassert(lp != lp);
+ }
+ return;
+}
+
+void lpx_unscale_prob(LPX *lp)
+{ /* unscale problem data */
+ glp_unscale_prob(lp);
+ return;
+}
+
+void lpx_set_row_stat(LPX *lp, int i, int stat)
+{ /* set (change) row status */
+ glp_set_row_stat(lp, i, stat - LPX_BS + GLP_BS);
+ return;
+}
+
+void lpx_set_col_stat(LPX *lp, int j, int stat)
+{ /* set (change) column status */
+ glp_set_col_stat(lp, j, stat - LPX_BS + GLP_BS);
+ return;
+}
+
+void lpx_std_basis(LPX *lp)
+{ /* construct standard initial LP basis */
+ glp_std_basis(lp);
+ return;
+}
+
+void lpx_adv_basis(LPX *lp)
+{ /* construct advanced initial LP basis */
+ glp_adv_basis(lp, 0);
+ return;
+}
+
+void lpx_cpx_basis(LPX *lp)
+{ /* construct Bixby's initial LP basis */
+ glp_cpx_basis(lp);
+ return;
+}
+
+static void fill_smcp(LPX *lp, glp_smcp *parm)
+{ glp_init_smcp(parm);
+ switch (lpx_get_int_parm(lp, LPX_K_MSGLEV))
+ { case 0: parm->msg_lev = GLP_MSG_OFF; break;
+ case 1: parm->msg_lev = GLP_MSG_ERR; break;
+ case 2: parm->msg_lev = GLP_MSG_ON; break;
+ case 3: parm->msg_lev = GLP_MSG_ALL; break;
+ default: xassert(lp != lp);
+ }
+ switch (lpx_get_int_parm(lp, LPX_K_DUAL))
+ { case 0: parm->meth = GLP_PRIMAL; break;
+ case 1: parm->meth = GLP_DUAL; break;
+ default: xassert(lp != lp);
+ }
+ switch (lpx_get_int_parm(lp, LPX_K_PRICE))
+ { case 0: parm->pricing = GLP_PT_STD; break;
+ case 1: parm->pricing = GLP_PT_PSE; break;
+ default: xassert(lp != lp);
+ }
+ if (lpx_get_real_parm(lp, LPX_K_RELAX) == 0.0)
+ parm->r_test = GLP_RT_STD;
+ else
+ parm->r_test = GLP_RT_HAR;
+ parm->tol_bnd = lpx_get_real_parm(lp, LPX_K_TOLBND);
+ parm->tol_dj = lpx_get_real_parm(lp, LPX_K_TOLDJ);
+ parm->tol_piv = lpx_get_real_parm(lp, LPX_K_TOLPIV);
+ parm->obj_ll = lpx_get_real_parm(lp, LPX_K_OBJLL);
+ parm->obj_ul = lpx_get_real_parm(lp, LPX_K_OBJUL);
+ if (lpx_get_int_parm(lp, LPX_K_ITLIM) < 0)
+ parm->it_lim = INT_MAX;
+ else
+ parm->it_lim = lpx_get_int_parm(lp, LPX_K_ITLIM);
+ if (lpx_get_real_parm(lp, LPX_K_TMLIM) < 0.0)
+ parm->tm_lim = INT_MAX;
+ else
+ parm->tm_lim =
+ (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_TMLIM));
+ parm->out_frq = lpx_get_int_parm(lp, LPX_K_OUTFRQ);
+ parm->out_dly =
+ (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_OUTDLY));
+ switch (lpx_get_int_parm(lp, LPX_K_PRESOL))
+ { case 0: parm->presolve = GLP_OFF; break;
+ case 1: parm->presolve = GLP_ON; break;
+ default: xassert(lp != lp);
+ }
+ return;
+}
+
+int lpx_simplex(LPX *lp)
+{ /* easy-to-use driver to the simplex method */
+ glp_smcp parm;
+ int ret;
+ fill_smcp(lp, &parm);
+ ret = glp_simplex(lp, &parm);
+ switch (ret)
+ { case 0: ret = LPX_E_OK; break;
+ case GLP_EBADB:
+ case GLP_ESING:
+ case GLP_ECOND:
+ case GLP_EBOUND: ret = LPX_E_FAULT; break;
+ case GLP_EFAIL: ret = LPX_E_SING; break;
+ case GLP_EOBJLL: ret = LPX_E_OBJLL; break;
+ case GLP_EOBJUL: ret = LPX_E_OBJUL; break;
+ case GLP_EITLIM: ret = LPX_E_ITLIM; break;
+ case GLP_ETMLIM: ret = LPX_E_TMLIM; break;
+ case GLP_ENOPFS: ret = LPX_E_NOPFS; break;
+ case GLP_ENODFS: ret = LPX_E_NODFS; break;
+ default: xassert(ret != ret);
+ }
+ return ret;
+}
+
+int lpx_exact(LPX *lp)
+{ /* easy-to-use driver to the exact simplex method */
+ glp_smcp parm;
+ int ret;
+ fill_smcp(lp, &parm);
+ ret = glp_exact(lp, &parm);
+ switch (ret)
+ { case 0: ret = LPX_E_OK; break;
+ case GLP_EBADB:
+ case GLP_ESING:
+ case GLP_EBOUND:
+ case GLP_EFAIL: ret = LPX_E_FAULT; break;
+ case GLP_EITLIM: ret = LPX_E_ITLIM; break;
+ case GLP_ETMLIM: ret = LPX_E_TMLIM; break;
+ default: xassert(ret != ret);
+ }
+ return ret;
+}
+
+int lpx_get_status(glp_prob *lp)
+{ /* retrieve generic status of basic solution */
+ int status;
+ switch (glp_get_status(lp))
+ { case GLP_OPT: status = LPX_OPT; break;
+ case GLP_FEAS: status = LPX_FEAS; break;
+ case GLP_INFEAS: status = LPX_INFEAS; break;
+ case GLP_NOFEAS: status = LPX_NOFEAS; break;
+ case GLP_UNBND: status = LPX_UNBND; break;
+ case GLP_UNDEF: status = LPX_UNDEF; break;
+ default: xassert(lp != lp);
+ }
+ return status;
+}
+
+int lpx_get_prim_stat(glp_prob *lp)
+{ /* retrieve status of primal basic solution */
+ return glp_get_prim_stat(lp) - GLP_UNDEF + LPX_P_UNDEF;
+}
+
+int lpx_get_dual_stat(glp_prob *lp)
+{ /* retrieve status of dual basic solution */
+ return glp_get_dual_stat(lp) - GLP_UNDEF + LPX_D_UNDEF;
+}
+
+double lpx_get_obj_val(LPX *lp)
+{ /* retrieve objective value (basic solution) */
+ return glp_get_obj_val(lp);
+}
+
+int lpx_get_row_stat(LPX *lp, int i)
+{ /* retrieve row status (basic solution) */
+ return glp_get_row_stat(lp, i) - GLP_BS + LPX_BS;
+}
+
+double lpx_get_row_prim(LPX *lp, int i)
+{ /* retrieve row primal value (basic solution) */
+ return glp_get_row_prim(lp, i);
+}
+
+double lpx_get_row_dual(LPX *lp, int i)
+{ /* retrieve row dual value (basic solution) */
+ return glp_get_row_dual(lp, i);
+}
+
+void lpx_get_row_info(glp_prob *lp, int i, int *tagx, double *vx,
+ double *dx)
+{ /* obtain row solution information */
+ if (tagx != NULL) *tagx = lpx_get_row_stat(lp, i);
+ if (vx != NULL) *vx = lpx_get_row_prim(lp, i);
+ if (dx != NULL) *dx = lpx_get_row_dual(lp, i);
+ return;
+}
+
+int lpx_get_col_stat(LPX *lp, int j)
+{ /* retrieve column status (basic solution) */
+ return glp_get_col_stat(lp, j) - GLP_BS + LPX_BS;
+}
+
+double lpx_get_col_prim(LPX *lp, int j)
+{ /* retrieve column primal value (basic solution) */
+ return glp_get_col_prim(lp, j);
+}
+
+double lpx_get_col_dual(glp_prob *lp, int j)
+{ /* retrieve column dual value (basic solution) */
+ return glp_get_col_dual(lp, j);
+}
+
+void lpx_get_col_info(glp_prob *lp, int j, int *tagx, double *vx,
+ double *dx)
+{ /* obtain column solution information */
+ if (tagx != NULL) *tagx = lpx_get_col_stat(lp, j);
+ if (vx != NULL) *vx = lpx_get_col_prim(lp, j);
+ if (dx != NULL) *dx = lpx_get_col_dual(lp, j);
+ return;
+}
+
+int lpx_get_ray_info(LPX *lp)
+{ /* determine what causes primal unboundness */
+ return glp_get_unbnd_ray(lp);
+}
+
+void lpx_check_kkt(LPX *lp, int scaled, LPXKKT *kkt)
+{ /* check Karush-Kuhn-Tucker conditions */
+ int ae_ind, re_ind;
+ double ae_max, re_max;
+ xassert(scaled == scaled);
+ glp_check_kkt(lp, GLP_SOL, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->pe_ae_max = ae_max;
+ kkt->pe_ae_row = ae_ind;
+ kkt->pe_re_max = re_max;
+ kkt->pe_re_row = re_ind;
+ if (re_max <= 1e-9)
+ kkt->pe_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->pe_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->pe_quality = 'L';
+ else
+ kkt->pe_quality = '?';
+ glp_check_kkt(lp, GLP_SOL, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->pb_ae_max = ae_max;
+ kkt->pb_ae_ind = ae_ind;
+ kkt->pb_re_max = re_max;
+ kkt->pb_re_ind = re_ind;
+ if (re_max <= 1e-9)
+ kkt->pb_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->pb_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->pb_quality = 'L';
+ else
+ kkt->pb_quality = '?';
+ glp_check_kkt(lp, GLP_SOL, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->de_ae_max = ae_max;
+ if (ae_ind == 0)
+ kkt->de_ae_col = 0;
+ else
+ kkt->de_ae_col = ae_ind - lp->m;
+ kkt->de_re_max = re_max;
+ if (re_ind == 0)
+ kkt->de_re_col = 0;
+ else
+ kkt->de_re_col = ae_ind - lp->m;
+ if (re_max <= 1e-9)
+ kkt->de_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->de_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->de_quality = 'L';
+ else
+ kkt->de_quality = '?';
+ glp_check_kkt(lp, GLP_SOL, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->db_ae_max = ae_max;
+ kkt->db_ae_ind = ae_ind;
+ kkt->db_re_max = re_max;
+ kkt->db_re_ind = re_ind;
+ if (re_max <= 1e-9)
+ kkt->db_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->db_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->db_quality = 'L';
+ else
+ kkt->db_quality = '?';
+ kkt->cs_ae_max = 0.0, kkt->cs_ae_ind = 0;
+ kkt->cs_re_max = 0.0, kkt->cs_re_ind = 0;
+ kkt->cs_quality = 'H';
+ return;
+}
+
+int lpx_warm_up(LPX *lp)
+{ /* "warm up" LP basis */
+ int ret;
+ ret = glp_warm_up(lp);
+ if (ret == 0)
+ ret = LPX_E_OK;
+ else if (ret == GLP_EBADB)
+ ret = LPX_E_BADB;
+ else if (ret == GLP_ESING)
+ ret = LPX_E_SING;
+ else if (ret == GLP_ECOND)
+ ret = LPX_E_SING;
+ else
+ xassert(ret != ret);
+ return ret;
+}
+
+int lpx_eval_tab_row(LPX *lp, int k, int ind[], double val[])
+{ /* compute row of the simplex tableau */
+ return glp_eval_tab_row(lp, k, ind, val);
+}
+
+int lpx_eval_tab_col(LPX *lp, int k, int ind[], double val[])
+{ /* compute column of the simplex tableau */
+ return glp_eval_tab_col(lp, k, ind, val);
+}
+
+int lpx_transform_row(LPX *lp, int len, int ind[], double val[])
+{ /* transform explicitly specified row */
+ return glp_transform_row(lp, len, ind, val);
+}
+
+int lpx_transform_col(LPX *lp, int len, int ind[], double val[])
+{ /* transform explicitly specified column */
+ return glp_transform_col(lp, len, ind, val);
+}
+
+int lpx_prim_ratio_test(LPX *lp, int len, const int ind[],
+ const double val[], int how, double tol)
+{ /* perform primal ratio test */
+ int piv;
+ piv = glp_prim_rtest(lp, len, ind, val, how, tol);
+ xassert(0 <= piv && piv <= len);
+ return piv == 0 ? 0 : ind[piv];
+}
+
+int lpx_dual_ratio_test(LPX *lp, int len, const int ind[],
+ const double val[], int how, double tol)
+{ /* perform dual ratio test */
+ int piv;
+ piv = glp_dual_rtest(lp, len, ind, val, how, tol);
+ xassert(0 <= piv && piv <= len);
+ return piv == 0 ? 0 : ind[piv];
+}
+
+int lpx_interior(LPX *lp)
+{ /* easy-to-use driver to the interior-point method */
+ int ret;
+ ret = glp_interior(lp, NULL);
+ switch (ret)
+ { case 0: ret = LPX_E_OK; break;
+ case GLP_EFAIL: ret = LPX_E_FAULT; break;
+ case GLP_ENOFEAS: ret = LPX_E_NOFEAS; break;
+ case GLP_ENOCVG: ret = LPX_E_NOCONV; break;
+ case GLP_EITLIM: ret = LPX_E_ITLIM; break;
+ case GLP_EINSTAB: ret = LPX_E_INSTAB; break;
+ default: xassert(ret != ret);
+ }
+ return ret;
+}
+
+int lpx_ipt_status(glp_prob *lp)
+{ /* retrieve status of interior-point solution */
+ int status;
+ switch (glp_ipt_status(lp))
+ { case GLP_UNDEF: status = LPX_T_UNDEF; break;
+ case GLP_OPT: status = LPX_T_OPT; break;
+ default: xassert(lp != lp);
+ }
+ return status;
+}
+
+double lpx_ipt_obj_val(LPX *lp)
+{ /* retrieve objective value (interior point) */
+ return glp_ipt_obj_val(lp);
+}
+
+double lpx_ipt_row_prim(LPX *lp, int i)
+{ /* retrieve row primal value (interior point) */
+ return glp_ipt_row_prim(lp, i);
+}
+
+double lpx_ipt_row_dual(LPX *lp, int i)
+{ /* retrieve row dual value (interior point) */
+ return glp_ipt_row_dual(lp, i);
+}
+
+double lpx_ipt_col_prim(LPX *lp, int j)
+{ /* retrieve column primal value (interior point) */
+ return glp_ipt_col_prim(lp, j);
+}
+
+double lpx_ipt_col_dual(LPX *lp, int j)
+{ /* retrieve column dual value (interior point) */
+ return glp_ipt_col_dual(lp, j);
+}
+
+void lpx_set_class(LPX *lp, int klass)
+{ /* set problem class */
+ xassert(lp == lp);
+ if (!(klass == LPX_LP || klass == LPX_MIP))
+ xerror("lpx_set_class: invalid problem class\n");
+ return;
+}
+
+int lpx_get_class(LPX *lp)
+{ /* determine problem klass */
+ return glp_get_num_int(lp) == 0 ? LPX_LP : LPX_MIP;
+}
+
+void lpx_set_col_kind(LPX *lp, int j, int kind)
+{ /* set (change) column kind */
+ glp_set_col_kind(lp, j, kind - LPX_CV + GLP_CV);
+ return;
+}
+
+int lpx_get_col_kind(LPX *lp, int j)
+{ /* retrieve column kind */
+ return glp_get_col_kind(lp, j) == GLP_CV ? LPX_CV : LPX_IV;
+}
+
+int lpx_get_num_int(LPX *lp)
+{ /* retrieve number of integer columns */
+ return glp_get_num_int(lp);
+}
+
+int lpx_get_num_bin(LPX *lp)
+{ /* retrieve number of binary columns */
+ return glp_get_num_bin(lp);
+}
+
+static int solve_mip(LPX *lp, int presolve)
+{ glp_iocp parm;
+ int ret;
+ glp_init_iocp(&parm);
+ switch (lpx_get_int_parm(lp, LPX_K_MSGLEV))
+ { case 0: parm.msg_lev = GLP_MSG_OFF; break;
+ case 1: parm.msg_lev = GLP_MSG_ERR; break;
+ case 2: parm.msg_lev = GLP_MSG_ON; break;
+ case 3: parm.msg_lev = GLP_MSG_ALL; break;
+ default: xassert(lp != lp);
+ }
+ switch (lpx_get_int_parm(lp, LPX_K_BRANCH))
+ { case 0: parm.br_tech = GLP_BR_FFV; break;
+ case 1: parm.br_tech = GLP_BR_LFV; break;
+ case 2: parm.br_tech = GLP_BR_DTH; break;
+ case 3: parm.br_tech = GLP_BR_MFV; break;
+ default: xassert(lp != lp);
+ }
+ switch (lpx_get_int_parm(lp, LPX_K_BTRACK))
+ { case 0: parm.bt_tech = GLP_BT_DFS; break;
+ case 1: parm.bt_tech = GLP_BT_BFS; break;
+ case 2: parm.bt_tech = GLP_BT_BPH; break;
+ case 3: parm.bt_tech = GLP_BT_BLB; break;
+ default: xassert(lp != lp);
+ }
+ parm.tol_int = lpx_get_real_parm(lp, LPX_K_TOLINT);
+ parm.tol_obj = lpx_get_real_parm(lp, LPX_K_TOLOBJ);
+ if (lpx_get_real_parm(lp, LPX_K_TMLIM) < 0.0 ||
+ lpx_get_real_parm(lp, LPX_K_TMLIM) > 1e6)
+ parm.tm_lim = INT_MAX;
+ else
+ parm.tm_lim =
+ (int)(1000.0 * lpx_get_real_parm(lp, LPX_K_TMLIM));
+ parm.mip_gap = lpx_get_real_parm(lp, LPX_K_MIPGAP);
+ if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_GOMORY)
+ parm.gmi_cuts = GLP_ON;
+ else
+ parm.gmi_cuts = GLP_OFF;
+ if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_MIR)
+ parm.mir_cuts = GLP_ON;
+ else
+ parm.mir_cuts = GLP_OFF;
+ if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_COVER)
+ parm.cov_cuts = GLP_ON;
+ else
+ parm.cov_cuts = GLP_OFF;
+ if (lpx_get_int_parm(lp, LPX_K_USECUTS) & LPX_C_CLIQUE)
+ parm.clq_cuts = GLP_ON;
+ else
+ parm.clq_cuts = GLP_OFF;
+ parm.presolve = presolve;
+ if (lpx_get_int_parm(lp, LPX_K_BINARIZE))
+ parm.binarize = GLP_ON;
+ ret = glp_intopt(lp, &parm);
+ switch (ret)
+ { case 0: ret = LPX_E_OK; break;
+ case GLP_ENOPFS: ret = LPX_E_NOPFS; break;
+ case GLP_ENODFS: ret = LPX_E_NODFS; break;
+ case GLP_EBOUND:
+ case GLP_EROOT: ret = LPX_E_FAULT; break;
+ case GLP_EFAIL: ret = LPX_E_SING; break;
+ case GLP_EMIPGAP: ret = LPX_E_MIPGAP; break;
+ case GLP_ETMLIM: ret = LPX_E_TMLIM; break;
+ default: xassert(ret != ret);
+ }
+ return ret;
+}
+
+int lpx_integer(LPX *lp)
+{ /* easy-to-use driver to the branch-and-bound method */
+ return solve_mip(lp, GLP_OFF);
+}
+
+int lpx_intopt(LPX *lp)
+{ /* easy-to-use driver to the branch-and-bound method */
+ return solve_mip(lp, GLP_ON);
+}
+
+int lpx_mip_status(glp_prob *lp)
+{ /* retrieve status of MIP solution */
+ int status;
+ switch (glp_mip_status(lp))
+ { case GLP_UNDEF: status = LPX_I_UNDEF; break;
+ case GLP_OPT: status = LPX_I_OPT; break;
+ case GLP_FEAS: status = LPX_I_FEAS; break;
+ case GLP_NOFEAS: status = LPX_I_NOFEAS; break;
+ default: xassert(lp != lp);
+ }
+ return status;
+}
+
+double lpx_mip_obj_val(LPX *lp)
+{ /* retrieve objective value (MIP solution) */
+ return glp_mip_obj_val(lp);
+}
+
+double lpx_mip_row_val(LPX *lp, int i)
+{ /* retrieve row value (MIP solution) */
+ return glp_mip_row_val(lp, i);
+}
+
+double lpx_mip_col_val(LPX *lp, int j)
+{ /* retrieve column value (MIP solution) */
+ return glp_mip_col_val(lp, j);
+}
+
+void lpx_check_int(LPX *lp, LPXKKT *kkt)
+{ /* check integer feasibility conditions */
+ int ae_ind, re_ind;
+ double ae_max, re_max;
+ glp_check_kkt(lp, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->pe_ae_max = ae_max;
+ kkt->pe_ae_row = ae_ind;
+ kkt->pe_re_max = re_max;
+ kkt->pe_re_row = re_ind;
+ if (re_max <= 1e-9)
+ kkt->pe_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->pe_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->pe_quality = 'L';
+ else
+ kkt->pe_quality = '?';
+ glp_check_kkt(lp, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
+ &re_ind);
+ kkt->pb_ae_max = ae_max;
+ kkt->pb_ae_ind = ae_ind;
+ kkt->pb_re_max = re_max;
+ kkt->pb_re_ind = re_ind;
+ if (re_max <= 1e-9)
+ kkt->pb_quality = 'H';
+ else if (re_max <= 1e-6)
+ kkt->pb_quality = 'M';
+ else if (re_max <= 1e-3)
+ kkt->pb_quality = 'L';
+ else
+ kkt->pb_quality = '?';
+ return;
+}
+
+#if 1 /* 17/XI-2009 */
+static void reset_parms(LPX *lp)
+{ /* reset control parameters to default values */
+ struct LPXCPS *cps = lp->parms;
+ xassert(cps != NULL);
+ cps->msg_lev = 3;
+ cps->scale = 1;
+ cps->dual = 0;
+ cps->price = 1;
+ cps->relax = 0.07;
+ cps->tol_bnd = 1e-7;
+ cps->tol_dj = 1e-7;
+ cps->tol_piv = 1e-9;
+ cps->round = 0;
+ cps->obj_ll = -DBL_MAX;
+ cps->obj_ul = +DBL_MAX;
+ cps->it_lim = -1;
+#if 0 /* 02/XII-2010 */
+ lp->it_cnt = 0;
+#endif
+ cps->tm_lim = -1.0;
+ cps->out_frq = 200;
+ cps->out_dly = 0.0;
+ cps->branch = 2;
+ cps->btrack = 3;
+ cps->tol_int = 1e-5;
+ cps->tol_obj = 1e-7;
+ cps->mps_info = 1;
+ cps->mps_obj = 2;
+ cps->mps_orig = 0;
+ cps->mps_wide = 1;
+ cps->mps_free = 0;
+ cps->mps_skip = 0;
+ cps->lpt_orig = 0;
+ cps->presol = 0;
+ cps->binarize = 0;
+ cps->use_cuts = 0;
+ cps->mip_gap = 0.0;
+ return;
+}
+#endif
+
+#if 1 /* 17/XI-2009 */
+static struct LPXCPS *access_parms(LPX *lp)
+{ /* allocate and initialize control parameters, if necessary */
+ if (lp->parms == NULL)
+ { lp->parms = xmalloc(sizeof(struct LPXCPS));
+ reset_parms(lp);
+ }
+ return lp->parms;
+}
+#endif
+
+#if 1 /* 17/XI-2009 */
+void lpx_reset_parms(LPX *lp)
+{ /* reset control parameters to default values */
+ access_parms(lp);
+ reset_parms(lp);
+ return;
+}
+#endif
+
+void lpx_set_int_parm(LPX *lp, int parm, int val)
+{ /* set (change) integer control parameter */
+#if 0 /* 17/XI-2009 */
+ struct LPXCPS *cps = lp->cps;
+#else
+ struct LPXCPS *cps = access_parms(lp);
+#endif
+ switch (parm)
+ { case LPX_K_MSGLEV:
+ if (!(0 <= val && val <= 3))
+ xerror("lpx_set_int_parm: MSGLEV = %d; invalid value\n",
+ val);
+ cps->msg_lev = val;
+ break;
+ case LPX_K_SCALE:
+ if (!(0 <= val && val <= 3))
+ xerror("lpx_set_int_parm: SCALE = %d; invalid value\n",
+ val);
+ cps->scale = val;
+ break;
+ case LPX_K_DUAL:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: DUAL = %d; invalid value\n",
+ val);
+ cps->dual = val;
+ break;
+ case LPX_K_PRICE:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: PRICE = %d; invalid value\n",
+ val);
+ cps->price = val;
+ break;
+ case LPX_K_ROUND:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: ROUND = %d; invalid value\n",
+ val);
+ cps->round = val;
+ break;
+ case LPX_K_ITLIM:
+ cps->it_lim = val;
+ break;
+ case LPX_K_ITCNT:
+ lp->it_cnt = val;
+ break;
+ case LPX_K_OUTFRQ:
+ if (!(val > 0))
+ xerror("lpx_set_int_parm: OUTFRQ = %d; invalid value\n",
+ val);
+ cps->out_frq = val;
+ break;
+ case LPX_K_BRANCH:
+ if (!(val == 0 || val == 1 || val == 2 || val == 3))
+ xerror("lpx_set_int_parm: BRANCH = %d; invalid value\n",
+ val);
+ cps->branch = val;
+ break;
+ case LPX_K_BTRACK:
+ if (!(val == 0 || val == 1 || val == 2 || val == 3))
+ xerror("lpx_set_int_parm: BTRACK = %d; invalid value\n",
+ val);
+ cps->btrack = val;
+ break;
+ case LPX_K_MPSINFO:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: MPSINFO = %d; invalid value\n",
+ val);
+ cps->mps_info = val;
+ break;
+ case LPX_K_MPSOBJ:
+ if (!(val == 0 || val == 1 || val == 2))
+ xerror("lpx_set_int_parm: MPSOBJ = %d; invalid value\n",
+ val);
+ cps->mps_obj = val;
+ break;
+ case LPX_K_MPSORIG:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: MPSORIG = %d; invalid value\n",
+ val);
+ cps->mps_orig = val;
+ break;
+ case LPX_K_MPSWIDE:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: MPSWIDE = %d; invalid value\n",
+ val);
+ cps->mps_wide = val;
+ break;
+ case LPX_K_MPSFREE:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: MPSFREE = %d; invalid value\n",
+ val);
+ cps->mps_free = val;
+ break;
+ case LPX_K_MPSSKIP:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: MPSSKIP = %d; invalid value\n",
+ val);
+ cps->mps_skip = val;
+ break;
+ case LPX_K_LPTORIG:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: LPTORIG = %d; invalid value\n",
+ val);
+ cps->lpt_orig = val;
+ break;
+ case LPX_K_PRESOL:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: PRESOL = %d; invalid value\n",
+ val);
+ cps->presol = val;
+ break;
+ case LPX_K_BINARIZE:
+ if (!(val == 0 || val == 1))
+ xerror("lpx_set_int_parm: BINARIZE = %d; invalid value\n"
+ , val);
+ cps->binarize = val;
+ break;
+ case LPX_K_USECUTS:
+ if (val & ~LPX_C_ALL)
+ xerror("lpx_set_int_parm: USECUTS = 0x%X; invalid value\n",
+ val);
+ cps->use_cuts = val;
+ break;
+ case LPX_K_BFTYPE:
+#if 0
+ if (!(1 <= val && val <= 3))
+ xerror("lpx_set_int_parm: BFTYPE = %d; invalid value\n",
+ val);
+ cps->bf_type = val;
+#else
+ { glp_bfcp parm;
+ glp_get_bfcp(lp, &parm);
+ switch (val)
+ { case 1:
+ parm.type = GLP_BF_FT; break;
+ case 2:
+ parm.type = GLP_BF_BG; break;
+ case 3:
+ parm.type = GLP_BF_GR; break;
+ default:
+ xerror("lpx_set_int_parm: BFTYPE = %d; invalid val"
+ "ue\n", val);
+ }
+ glp_set_bfcp(lp, &parm);
+ }
+#endif
+ break;
+ default:
+ xerror("lpx_set_int_parm: parm = %d; invalid parameter\n",
+ parm);
+ }
+ return;
+}
+
+int lpx_get_int_parm(LPX *lp, int parm)
+{ /* query integer control parameter */
+#if 0 /* 17/XI-2009 */
+ struct LPXCPS *cps = lp->cps;
+#else
+ struct LPXCPS *cps = access_parms(lp);
+#endif
+ int val = 0;
+ switch (parm)
+ { case LPX_K_MSGLEV:
+ val = cps->msg_lev; break;
+ case LPX_K_SCALE:
+ val = cps->scale; break;
+ case LPX_K_DUAL:
+ val = cps->dual; break;
+ case LPX_K_PRICE:
+ val = cps->price; break;
+ case LPX_K_ROUND:
+ val = cps->round; break;
+ case LPX_K_ITLIM:
+ val = cps->it_lim; break;
+ case LPX_K_ITCNT:
+ val = lp->it_cnt; break;
+ case LPX_K_OUTFRQ:
+ val = cps->out_frq; break;
+ case LPX_K_BRANCH:
+ val = cps->branch; break;
+ case LPX_K_BTRACK:
+ val = cps->btrack; break;
+ case LPX_K_MPSINFO:
+ val = cps->mps_info; break;
+ case LPX_K_MPSOBJ:
+ val = cps->mps_obj; break;
+ case LPX_K_MPSORIG:
+ val = cps->mps_orig; break;
+ case LPX_K_MPSWIDE:
+ val = cps->mps_wide; break;
+ case LPX_K_MPSFREE:
+ val = cps->mps_free; break;
+ case LPX_K_MPSSKIP:
+ val = cps->mps_skip; break;
+ case LPX_K_LPTORIG:
+ val = cps->lpt_orig; break;
+ case LPX_K_PRESOL:
+ val = cps->presol; break;
+ case LPX_K_BINARIZE:
+ val = cps->binarize; break;
+ case LPX_K_USECUTS:
+ val = cps->use_cuts; break;
+ case LPX_K_BFTYPE:
+#if 0
+ val = cps->bf_type; break;
+#else
+ { glp_bfcp parm;
+ glp_get_bfcp(lp, &parm);
+ switch (parm.type)
+ { case GLP_BF_FT:
+ val = 1; break;
+ case GLP_BF_BG:
+ val = 2; break;
+ case GLP_BF_GR:
+ val = 3; break;
+ default:
+ xassert(lp != lp);
+ }
+ }
+ break;
+#endif
+ default:
+ xerror("lpx_get_int_parm: parm = %d; invalid parameter\n",
+ parm);
+ }
+ return val;
+}
+
+void lpx_set_real_parm(LPX *lp, int parm, double val)
+{ /* set (change) real control parameter */
+#if 0 /* 17/XI-2009 */
+ struct LPXCPS *cps = lp->cps;
+#else
+ struct LPXCPS *cps = access_parms(lp);
+#endif
+ switch (parm)
+ { case LPX_K_RELAX:
+ if (!(0.0 <= val && val <= 1.0))
+ xerror("lpx_set_real_parm: RELAX = %g; invalid value\n",
+ val);
+ cps->relax = val;
+ break;
+ case LPX_K_TOLBND:
+ if (!(DBL_EPSILON <= val && val <= 0.001))
+ xerror("lpx_set_real_parm: TOLBND = %g; invalid value\n",
+ val);
+#if 0
+ if (cps->tol_bnd > val)
+ { /* invalidate the basic solution */
+ lp->p_stat = LPX_P_UNDEF;
+ lp->d_stat = LPX_D_UNDEF;
+ }
+#endif
+ cps->tol_bnd = val;
+ break;
+ case LPX_K_TOLDJ:
+ if (!(DBL_EPSILON <= val && val <= 0.001))
+ xerror("lpx_set_real_parm: TOLDJ = %g; invalid value\n",
+ val);
+#if 0
+ if (cps->tol_dj > val)
+ { /* invalidate the basic solution */
+ lp->p_stat = LPX_P_UNDEF;
+ lp->d_stat = LPX_D_UNDEF;
+ }
+#endif
+ cps->tol_dj = val;
+ break;
+ case LPX_K_TOLPIV:
+ if (!(DBL_EPSILON <= val && val <= 0.001))
+ xerror("lpx_set_real_parm: TOLPIV = %g; invalid value\n",
+ val);
+ cps->tol_piv = val;
+ break;
+ case LPX_K_OBJLL:
+ cps->obj_ll = val;
+ break;
+ case LPX_K_OBJUL:
+ cps->obj_ul = val;
+ break;
+ case LPX_K_TMLIM:
+ cps->tm_lim = val;
+ break;
+ case LPX_K_OUTDLY:
+ cps->out_dly = val;
+ break;
+ case LPX_K_TOLINT:
+ if (!(DBL_EPSILON <= val && val <= 0.001))
+ xerror("lpx_set_real_parm: TOLINT = %g; invalid value\n",
+ val);
+ cps->tol_int = val;
+ break;
+ case LPX_K_TOLOBJ:
+ if (!(DBL_EPSILON <= val && val <= 0.001))
+ xerror("lpx_set_real_parm: TOLOBJ = %g; invalid value\n",
+ val);
+ cps->tol_obj = val;
+ break;
+ case LPX_K_MIPGAP:
+ if (val < 0.0)
+ xerror("lpx_set_real_parm: MIPGAP = %g; invalid value\n",
+ val);
+ cps->mip_gap = val;
+ break;
+ default:
+ xerror("lpx_set_real_parm: parm = %d; invalid parameter\n",
+ parm);
+ }
+ return;
+}
+
+double lpx_get_real_parm(LPX *lp, int parm)
+{ /* query real control parameter */
+#if 0 /* 17/XI-2009 */
+ struct LPXCPS *cps = lp->cps;
+#else
+ struct LPXCPS *cps = access_parms(lp);
+#endif
+ double val = 0.0;
+ switch (parm)
+ { case LPX_K_RELAX:
+ val = cps->relax;
+ break;
+ case LPX_K_TOLBND:
+ val = cps->tol_bnd;
+ break;
+ case LPX_K_TOLDJ:
+ val = cps->tol_dj;
+ break;
+ case LPX_K_TOLPIV:
+ val = cps->tol_piv;
+ break;
+ case LPX_K_OBJLL:
+ val = cps->obj_ll;
+ break;
+ case LPX_K_OBJUL:
+ val = cps->obj_ul;
+ break;
+ case LPX_K_TMLIM:
+ val = cps->tm_lim;
+ break;
+ case LPX_K_OUTDLY:
+ val = cps->out_dly;
+ break;
+ case LPX_K_TOLINT:
+ val = cps->tol_int;
+ break;
+ case LPX_K_TOLOBJ:
+ val = cps->tol_obj;
+ break;
+ case LPX_K_MIPGAP:
+ val = cps->mip_gap;
+ break;
+ default:
+ xerror("lpx_get_real_parm: parm = %d; invalid parameter\n",
+ parm);
+ }
+ return val;
+}
+
+LPX *lpx_read_mps(const char *fname)
+{ /* read problem data in fixed MPS format */
+ LPX *lp = lpx_create_prob();
+ if (glp_read_mps(lp, GLP_MPS_DECK, NULL, fname))
+ lpx_delete_prob(lp), lp = NULL;
+ return lp;
+}
+
+int lpx_write_mps(LPX *lp, const char *fname)
+{ /* write problem data in fixed MPS format */
+ return glp_write_mps(lp, GLP_MPS_DECK, NULL, fname);
+}
+
+int lpx_read_bas(LPX *lp, const char *fname)
+{ /* read LP basis in fixed MPS format */
+#if 0 /* 13/IV-2009 */
+ return read_bas(lp, fname);
+#else
+ xassert(lp == lp);
+ xassert(fname == fname);
+ xerror("lpx_read_bas: operation not supported\n");
+ return 0;
+#endif
+}
+
+int lpx_write_bas(LPX *lp, const char *fname)
+{ /* write LP basis in fixed MPS format */
+#if 0 /* 13/IV-2009 */
+ return write_bas(lp, fname);
+#else
+ xassert(lp == lp);
+ xassert(fname == fname);
+ xerror("lpx_write_bas: operation not supported\n");
+ return 0;
+#endif
+}
+
+LPX *lpx_read_freemps(const char *fname)
+{ /* read problem data in free MPS format */
+ LPX *lp = lpx_create_prob();
+ if (glp_read_mps(lp, GLP_MPS_FILE, NULL, fname))
+ lpx_delete_prob(lp), lp = NULL;
+ return lp;
+}
+
+int lpx_write_freemps(LPX *lp, const char *fname)
+{ /* write problem data in free MPS format */
+ return glp_write_mps(lp, GLP_MPS_FILE, NULL, fname);
+}
+
+LPX *lpx_read_cpxlp(const char *fname)
+{ /* read problem data in CPLEX LP format */
+ LPX *lp;
+ lp = lpx_create_prob();
+ if (glp_read_lp(lp, NULL, fname))
+ lpx_delete_prob(lp), lp = NULL;
+ return lp;
+}
+
+int lpx_write_cpxlp(LPX *lp, const char *fname)
+{ /* write problem data in CPLEX LP format */
+ return glp_write_lp(lp, NULL, fname);
+}
+
+LPX *lpx_read_model(const char *model, const char *data, const char
+ *output)
+{ /* read LP/MIP model written in GNU MathProg language */
+ LPX *lp = NULL;
+ glp_tran *tran;
+ /* allocate the translator workspace */
+ tran = glp_mpl_alloc_wksp();
+ /* read model section and optional data section */
+ if (glp_mpl_read_model(tran, model, data != NULL)) goto done;
+ /* read separate data section, if required */
+ if (data != NULL)
+ if (glp_mpl_read_data(tran, data)) goto done;
+ /* generate the model */
+ if (glp_mpl_generate(tran, output)) goto done;
+ /* build the problem instance from the model */
+ lp = glp_create_prob();
+ glp_mpl_build_prob(tran, lp);
+done: /* free the translator workspace */
+ glp_mpl_free_wksp(tran);
+ /* bring the problem object to the calling program */
+ return lp;
+}
+
+int lpx_print_prob(LPX *lp, const char *fname)
+{ /* write problem data in plain text format */
+ return glp_write_lp(lp, NULL, fname);
+}
+
+int lpx_print_sol(LPX *lp, const char *fname)
+{ /* write LP problem solution in printable format */
+ return glp_print_sol(lp, fname);
+}
+
+int lpx_print_sens_bnds(LPX *lp, const char *fname)
+{ /* write bounds sensitivity information */
+ if (glp_get_status(lp) == GLP_OPT && !glp_bf_exists(lp))
+ glp_factorize(lp);
+ return glp_print_ranges(lp, 0, NULL, 0, fname);
+}
+
+int lpx_print_ips(LPX *lp, const char *fname)
+{ /* write interior point solution in printable format */
+ return glp_print_ipt(lp, fname);
+}
+
+int lpx_print_mip(LPX *lp, const char *fname)
+{ /* write MIP problem solution in printable format */
+ return glp_print_mip(lp, fname);
+}
+
+int lpx_is_b_avail(glp_prob *lp)
+{ /* check if LP basis is available */
+ return glp_bf_exists(lp);
+}
+
+int lpx_main(int argc, const char *argv[])
+{ /* stand-alone LP/MIP solver */
+ return glp_main(argc, argv);
+}
+
+/* eof */
Index: 4ti2-1.6/src/groebner/stdc.h
===================================================================
--- /dev/null
+++ 4ti2-1.6/src/groebner/stdc.h
@@ -0,0 +1,42 @@
+/* stdc.h (standard ANSI C headers) */
+
+/***********************************************************************
+* This code is part of GLPK (GNU Linear Programming Kit).
+*
+* Copyright (C) 2000, 2013 Andrew Makhorin, Department for Applied
+* Informatics, Moscow Aviation Institute, Moscow, Russia. All rights
+* reserved. E-mail: <mao@gnu.org>.
+*
+* GLPK is free software: you can redistribute it and/or modify it
+* under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* GLPK is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+* License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GLPK. If not, see <http://www.gnu.org/licenses/>.
+***********************************************************************/
+
+#ifndef STDC_H
+#define STDC_H
+
+#include <ctype.h>
+#include <errno.h>
+#include <float.h>
+#include <limits.h>
+#include <math.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#endif
+
+/* eof */
View Git Blame Copy Permalink