diff --git a/4ti2-1.6.2.tar.gz b/4ti2-1.6.2.tar.gz new file mode 100644 index 0000000..b3205f6 --- /dev/null +++ b/4ti2-1.6.2.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1b39c5c051904e41deefce5419b16d723b1f403c616ddd6e3610e260d4b5711 +size 5531651 diff --git a/4ti2-1.6.tar.gz b/4ti2-1.6.tar.gz deleted file mode 100644 index 7bacfcf..0000000 --- a/4ti2-1.6.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:5edd106a3584408d89c58cb432f8b08eec472aa3277a35928523cdb4e43c769e -size 5556747 diff --git a/4ti2-glpk.diff b/4ti2-glpk.diff deleted file mode 100644 index 0a7633b..0000000 --- a/4ti2-glpk.diff +++ /dev/null @@ -1,3067 +0,0 @@ -From: Jan Engelhardt -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 --}], [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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#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: . -+* -+* 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 . -+***********************************************************************/ -+ -+#ifndef STDC_H -+#define STDC_H -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#endif -+ -+/* eof */ diff --git a/4ti2.changes b/4ti2.changes index ebcd9ff..31b4dda 100644 --- a/4ti2.changes +++ b/4ti2.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Fri Apr 18 09:33:38 UTC 2014 - jengelh@inai.de + +- Update to new upstream release 1.6.2 +* Support for newer libglpk API "glp_" + (which replaced the "lpx_" API) + ------------------------------------------------------------------- Tue Feb 4 18:39:35 UTC 2014 - jengelh@inai.de diff --git a/4ti2.spec b/4ti2.spec index 4d2a47b..9cded70 100644 --- a/4ti2.spec +++ b/4ti2.spec @@ -17,16 +17,15 @@ Name: 4ti2 -Version: 1.6 +Version: 1.6.2 Release: 0 Summary: Package for algebraic, geometric and combinatorial problems on linear spaces License: GPL-2.0+ Group: Productivity/Scientific/Math Url: http://4ti2.de/ -Source: http://4ti2.de/version_1.6/%name-%version.tar.gz +Source: http://4ti2.de/version_%version/%name-%version.tar.gz Patch1: 4ti2-missing-libs.diff -Patch2: 4ti2-glpk.diff Patch3: 4ti2-docdir.diff BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: autoconf >= 2.59 @@ -71,7 +70,7 @@ developing against 4ti2's libraries. %prep %setup -q -%patch -P 1 -P 2 -P 3 -p1 +%patch -P 1 -P 3 -p1 %build autoreconf -fi;