diff --git a/4ti2-1.3.2.tar.xz b/4ti2-1.3.2.tar.xz deleted file mode 100644 index 595ca78..0000000 --- a/4ti2-1.3.2.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:1bbe07f04cd4e9404867ceaf842518d1f978dcbee8841590dfb8f82cde23cd65 -size 2002404 diff --git a/4ti2-1.6.tar.gz b/4ti2-1.6.tar.gz new file mode 100644 index 0000000..7bacfcf --- /dev/null +++ b/4ti2-1.6.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5edd106a3584408d89c58cb432f8b08eec472aa3277a35928523cdb4e43c769e +size 5556747 diff --git a/4ti2-doc.tar.xz b/4ti2-doc.tar.xz deleted file mode 100644 index 1185703..0000000 --- a/4ti2-doc.tar.xz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:62b4cab56ab3a5d4555732847fb9fa547a04f66422576fee6453079b960691e7 -size 343396 diff --git a/4ti2-docdir.diff b/4ti2-docdir.diff new file mode 100644 index 0000000..990cfe2 --- /dev/null +++ b/4ti2-docdir.diff @@ -0,0 +1,21 @@ +From: Jan Engelhardt +Date: 2014-02-05 00:33:39.300262391 +0100 + +build: stop misplacing documentation + +docdir must not be statically set as it would override what the +user gave to ./configure --docdir=... + +--- + doc/Makefile.am | 1 - + 1 file changed, 1 deletion(-) + +Index: 4ti2-1.6/doc/Makefile.am +=================================================================== +--- 4ti2-1.6.orig/doc/Makefile.am ++++ 4ti2-1.6/doc/Makefile.am +@@ -1,4 +1,3 @@ +-docdir = $(pkgdatadir)/doc + + doc_DATA = 4ti2_manual.pdf + diff --git a/4ti2-gcc.diff b/4ti2-gcc.diff deleted file mode 100644 index bcd6441..0000000 --- a/4ti2-gcc.diff +++ /dev/null @@ -1,356 +0,0 @@ -From: Jan Engelhardt -Date: 2012-12-06 11:33:01.767857267 +0100 - -build: resolve coding errors after stricter C++ checks - -CircuitMatrixAlgorithm.tpp:155:51: error: 'next_column' was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation [-fpermissive] -CircuitMatrixAlgorithm.tpp:155:51: note: declarations in dependent base '_4ti2_::CircuitImplementation<_4ti2_::ShortDenseIndexSet>' are not found by unqualified lookup -CircuitMatrixAlgorithm.tpp:155:51: note: use 'this->next_column' instead -[...] - ---- - src/groebner/CircuitMatrixAlgorithm.tpp | 28 ++++++++++++------------ - src/groebner/CircuitSupportAlgorithm.tpp | 36 +++++++++++++++---------------- - src/groebner/RayMatrixAlgorithm.tpp | 20 ++++++++--------- - src/groebner/RaySupportAlgorithm.tpp | 22 +++++++++--------- - 4 files changed, 53 insertions(+), 53 deletions(-) - -Index: 4ti2-1.3.2/src/groebner/CircuitMatrixAlgorithm.tpp -=================================================================== ---- 4ti2-1.3.2.orig/src/groebner/CircuitMatrixAlgorithm.tpp -+++ 4ti2-1.3.2/src/groebner/CircuitMatrixAlgorithm.tpp -@@ -152,23 +152,23 @@ CircuitMatrixAlgorithm::comput - ) - - // Find the next column. -- Index next_col = next_column(vs, remaining); -+ Index next_col = this->next_column(vs, remaining); - - int start = 0; int end = vs.get_number(); int middle; - // We sort the vectors into nonzeros and then zeros. -- sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle); - int nonzero_start = start, nonzero_end = middle; - //int zero_start = middle, zero_end = end; - // We sort the nonzeros into rays and circuits. -- sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle); -+ this->sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle); - int ray_start = nonzero_start, ray_end = middle; - int cir_start = middle, cir_end = nonzero_end; - // We sort the rays into positives and then negatives. -- sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle); - int pos_ray_start = ray_start, pos_ray_end = middle; - int neg_ray_start = middle, neg_ray_end = ray_end; - // We sort the circuits into positives and then negatives. -- sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle); - int pos_cir_start = cir_start, pos_cir_end = middle; - int neg_cir_start = middle, neg_cir_end = cir_end; - -@@ -185,8 +185,8 @@ CircuitMatrixAlgorithm::comput - - // Switch the positive and negative supports, so that it is as if all - // vectors have a positive entry in the next column. -- switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -- switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); -+ this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -+ this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); - - matrix = orig_matrix; - int remaining_row = upper_triangle(matrix, remaining, 0); -@@ -212,15 +212,15 @@ CircuitMatrixAlgorithm::comput - rays.insert(rays.end(), vs.get_number()-previous_size, false); - - // Switch back the positive and negative supports. -- switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -- switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); -+ this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -+ this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); - - // Update the supp vectors for the next_col. -- update_supports(supps, next_col, nonzero_start, nonzero_end); -- update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end); -- update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end); -- update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end); -- update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end); -+ this->update_supports(supps, next_col, nonzero_start, nonzero_end); -+ this->update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end); -+ this->update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end); -+ this->update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end); -+ this->update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end); - - *out << "\r"; - *out << " Left = " << std::setw(3) << num_remaining; -Index: 4ti2-1.3.2/src/groebner/CircuitSupportAlgorithm.tpp -=================================================================== ---- 4ti2-1.3.2.orig/src/groebner/CircuitSupportAlgorithm.tpp -+++ 4ti2-1.3.2/src/groebner/CircuitSupportAlgorithm.tpp -@@ -188,23 +188,23 @@ CircuitSupportAlgorithm::compu - ) - - // Find the next column. -- Index next_col = next_column(vs, remaining); -+ Index next_col = this->next_column(vs, remaining); - - int start = 0; int end = vs.get_number(); int middle; - // We sort the vectors into nonzeros and then zeros. -- sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle); - int nonzero_start = start, nonzero_end = middle; - //int zero_start = middle, zero_end = end; - // We sort the nonzeros into rays and circuits. -- sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle); -+ this->sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle); - int ray_start = nonzero_start, ray_end = middle; - int cir_start = middle, cir_end = nonzero_end; - // We sort the rays into positives and then negatives. -- sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle); - int pos_ray_start = ray_start, pos_ray_end = middle; - int neg_ray_start = middle, neg_ray_end = ray_end; - // We sort the circuits into positives and the negatives. -- sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle); -+ this->sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle); - int pos_cir_start = cir_start, pos_cir_end = middle; - int neg_cir_start = middle, neg_cir_end = cir_end; - -@@ -233,8 +233,8 @@ CircuitSupportAlgorithm::compu - - // Switch the positive and negative supports, so that it is as if all - // vectors have a positive entry in the next column. -- switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -- switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); -+ this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -+ this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); - - //DEBUG_4ti2(*out << "Remaining row " << remaining_row << "\n";) - int previous_size = vs.get_number(); -@@ -258,19 +258,19 @@ CircuitSupportAlgorithm::compu - rays.insert(rays.end(), vs.get_number()-previous_size, false); - - // Switch back the positive and negative supports. -- switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -- switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); -+ this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps); -+ this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps); - - // Update the supp vectors for the next_col. -- update_supports(supps, next_col, nonzero_start, nonzero_end); -- update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end); -- update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end); -- update_supports(pos_supps, col_map[next_col], neg_ray_start, neg_ray_end); -- update_supports(pos_supps, col_map[next_col], neg_cir_start, neg_cir_end); -- update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end); -- update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end); -- update_supports(neg_supps, col_map[next_col], pos_ray_start, pos_ray_end); -- update_supports(neg_supps, col_map[next_col], pos_cir_start, pos_cir_end); -+ this->update_supports(supps, next_col, nonzero_start, nonzero_end); -+ this->update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end); -+ this->update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end); -+ this->update_supports(pos_supps, col_map[next_col], neg_ray_start, neg_ray_end); -+ this->update_supports(pos_supps, col_map[next_col], neg_cir_start, neg_cir_end); -+ this->update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end); -+ this->update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end); -+ this->update_supports(neg_supps, col_map[next_col], pos_ray_start, pos_ray_end); -+ this->update_supports(neg_supps, col_map[next_col], pos_cir_start, pos_cir_end); - - *out << "\r"; - *out << " Left = " << std::setw(3) << num_remaining; -Index: 4ti2-1.3.2/src/groebner/RayMatrixAlgorithm.tpp -=================================================================== ---- 4ti2-1.3.2.orig/src/groebner/RayMatrixAlgorithm.tpp -+++ 4ti2-1.3.2/src/groebner/RayMatrixAlgorithm.tpp -@@ -161,7 +161,7 @@ RayMatrixAlgorithm::compute1( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - matrix = orig_matrix; -@@ -366,7 +366,7 @@ RayMatrixAlgorithm::compute0( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - matrix = orig_matrix; -@@ -615,7 +615,7 @@ RayMatrixAlgorithm::compute2( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, fathers, zeros, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, fathers, zeros, next_col, next_zero_count, next_positive_count, - next_negative_count); - - matrix = orig_matrix; -@@ -865,7 +865,7 @@ RayMatrixAlgorithm::compute3( - DEBUG_4ti2(unsigned long long int num_checks = 0;) - // Find the next column. - int next_positive_count, next_negative_count, next_zero_count; -- Index next_col = next_column(vs, remaining, -+ Index next_col = this->next_column(vs, remaining, - next_positive_count, - next_negative_count, - next_zero_count); -@@ -880,7 +880,7 @@ RayMatrixAlgorithm::compute3( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - DEBUG_4ti2(*out << "Rays:\n" << vs << "\n";) -@@ -944,7 +944,7 @@ RayMatrixAlgorithm::compute3( - IndexSet::set_difference(supports[r2], r1_supp, temp_diff); - if (temp_diff.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -@@ -959,7 +959,7 @@ RayMatrixAlgorithm::compute3( - IndexSet::set_difference(r1_supp, supports[r2], temp_diff); - if (temp_diff.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -@@ -984,7 +984,7 @@ RayMatrixAlgorithm::compute3( - IndexSet::set_difference(r1_supp, supports[r2], temp_diff2); - if (temp_diff2.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -@@ -996,7 +996,7 @@ RayMatrixAlgorithm::compute3( - DEBUG_4ti2(++num_checks;) - if (rank_check(matrix, temp_matrix, temp_diff, r1_rows)) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_added;) -@@ -1012,7 +1012,7 @@ RayMatrixAlgorithm::compute3( - IndexSet::set_difference(supports[r2], r1_supp, temp_diff); - if (temp_diff.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -Index: 4ti2-1.3.2/src/groebner/RaySupportAlgorithm.tpp -=================================================================== ---- 4ti2-1.3.2.orig/src/groebner/RaySupportAlgorithm.tpp -+++ 4ti2-1.3.2/src/groebner/RaySupportAlgorithm.tpp -@@ -153,7 +153,7 @@ RaySupportAlgorithm::compute0( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - // Note that the tree needs the ordering of the current vectors to be -@@ -352,7 +352,7 @@ RaySupportAlgorithm::compute1( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - // Note that the tree needs the ordering of the current vectors to be -@@ -565,7 +565,7 @@ RaySupportAlgorithm::compute2( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - // Note that the tree needs the ordering of the current vectors to be -@@ -773,7 +773,7 @@ RaySupportAlgorithm::compute3( - - // Find the next column. - int next_positive_count, next_negative_count, next_zero_count; -- Index next_col = next_column(vs, remaining, -+ Index next_col = this->next_column(vs, remaining, - next_positive_count, - next_negative_count, - next_zero_count); -@@ -788,7 +788,7 @@ RaySupportAlgorithm::compute3( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - int original_size = vs.get_number(); -@@ -852,7 +852,7 @@ RaySupportAlgorithm::compute3( - IndexSet::set_difference(supports[r2], r1_supp, temp_diff); - if (temp_diff.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_added;) -@@ -866,7 +866,7 @@ RaySupportAlgorithm::compute3( - IndexSet::set_difference(r1_supp, supports[r2], temp_diff); - if (temp_diff.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -@@ -885,7 +885,7 @@ RaySupportAlgorithm::compute3( - zero_supp.set_union(supports[index]); - if (index >= r2_index && index < r2_finish) - { -- create_new_vector(vs, supports, r1, index, next_col, -+ this->create_new_vector(vs, supports, r1, index, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_added;) -@@ -905,7 +905,7 @@ RaySupportAlgorithm::compute3( - IndexSet::set_difference(r1_supp, supports[r2], temp_diff2); - if (temp_diff2.power_of_2()) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_one_diff_added;) -@@ -918,7 +918,7 @@ RaySupportAlgorithm::compute3( - DEBUG_4ti2(++num_checks;) - if (!tree.dominated(temp_supp, r1, r2)) - { -- create_new_vector(vs, supports, r1, r2, next_col, -+ this->create_new_vector(vs, supports, r1, r2, next_col, - next_positive_count, next_negative_count, - temp, temp_supp); - DEBUG_4ti2(++num_added;) -@@ -1045,7 +1045,7 @@ RaySupportAlgorithm::compute4( - ) - - // We sort the vectors into zeros, positives, then negatives. -- sort(vs, supports, next_col, next_zero_count, next_positive_count, -+ this->sort(vs, supports, next_col, next_zero_count, next_positive_count, - next_negative_count); - - int original_size = vs.get_number(); diff --git a/4ti2-glpk.diff b/4ti2-glpk.diff new file mode 100644 index 0000000..0a7633b --- /dev/null +++ b/4ti2-glpk.diff @@ -0,0 +1,3067 @@ +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-libtool.diff b/4ti2-libtool.diff deleted file mode 100644 index f3803b8..0000000 --- a/4ti2-libtool.diff +++ /dev/null @@ -1,26 +0,0 @@ -From: Jan Engelhardt -Date: 2012-12-06 16:01:44.178343276 +0100 - -build: resolve failure to run libtool - -configure would not detect GLPK's presence if the libtool -call failed, and it does when --tag is not specified. -Happens in libtool < 2.4. - ---- - m4/glpk-check.m4 | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -Index: 4ti2-1.3.2/m4/glpk-check.m4 -=================================================================== ---- 4ti2-1.3.2.orig/m4/glpk-check.m4 -+++ 4ti2-1.3.2/m4/glpk-check.m4 -@@ -27,7 +27,7 @@ BACKUP_CXXFLAGS=${CXXFLAGS} - BACKUP_LIBS=${LIBS} - BACKUP_CXX=${CXX} - --CXX="./libtool --mode=link ${CXX}" -+CXX="./libtool --tag=CXX --mode=link ${CXX}" - - AC_MSG_CHECKING(for GLPK) - diff --git a/4ti2-nonvoid-return.diff b/4ti2-nonvoid-return.diff deleted file mode 100644 index 07a8f4c..0000000 --- a/4ti2-nonvoid-return.diff +++ /dev/null @@ -1,22 +0,0 @@ -From: Jan Engelhardt -Date: 2012-12-06 15:33:29.895691589 +0100 - -build: resolve -Wreturn-type warnings - -qsolve_main.cpp: In function 'bool input_Rel(const char*, _4ti2_::BitSet&, _4ti2_::BitSet&, _4ti2_::BitSet&)': -qsolve_main.cpp:336:1: warning: control reaches end of non-void function [-Wreturn-type] - ---- - src/groebner/qsolve_main.cpp | 1 + - 1 file changed, 1 insertion(+) - -Index: 4ti2-1.3.2/src/groebner/qsolve_main.cpp -=================================================================== ---- 4ti2-1.3.2.orig/src/groebner/qsolve_main.cpp -+++ 4ti2-1.3.2/src/groebner/qsolve_main.cpp -@@ -333,4 +333,5 @@ input_Rel(const char* rel_filename, BitS - std::cerr << "INPUT ERROR: Check there are only the characters =, <, and >.\n"; - exit(1); - } -+ return 1; - } diff --git a/4ti2.changes b/4ti2.changes index 7b9a858..ebcd9ff 100644 --- a/4ti2.changes +++ b/4ti2.changes @@ -1,3 +1,13 @@ +------------------------------------------------------------------- +Tue Feb 4 18:39:35 UTC 2014 - jengelh@inai.de + +- Update to new upstream release 1.6 +* Restore the functionality of "hilbert" to accept "rel" files +* When the cone is not pointed, "hilbert" now outputs a "zfree" file, + containing a lattice basis, in addition to the "hil" file. +- Remove 4ti2-gcc.diff, 4ti2-nonvoid-return.diff, 4ti2-libtool.diff + (merged upstream) + ------------------------------------------------------------------- Wed Apr 17 08:05:30 UTC 2013 - jengelh@inai.de diff --git a/4ti2.spec b/4ti2.spec index 208a278..4d2a47b 100644 --- a/4ti2.spec +++ b/4ti2.spec @@ -17,27 +17,24 @@ Name: 4ti2 -Version: 1.3.2 +Version: 1.6 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: %name-%version.tar.xz -Source2: %name-doc.tar.xz -Patch1: 4ti2-gcc.diff -Patch2: 4ti2-missing-libs.diff -Patch3: 4ti2-nonvoid-return.diff -Patch4: 4ti2-libtool.diff +Source: http://4ti2.de/version_1.6/%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 BuildRequires: automake -BuildRequires: gcc-c++ >= 3.4 -BuildRequires: glpk-devel +BuildRequires: gcc-c++ >= 4.3 +BuildRequires: glpk-devel >= 4.52 BuildRequires: gmp-devel >= 4.1.4 BuildRequires: libtool -BuildRequires: xz %description 4ti2 is a collection of programs that compute and solve algebraic, @@ -73,29 +70,25 @@ This subpackage contains the include files and library links for developing against 4ti2's libraries. %prep -%setup -qa2 -%patch -P 1 -P 2 -P 3 -P 4 -p1 +%setup -q +%patch -P 1 -P 2 -P 3 -p1 %build autoreconf -fi; -if [ ! -e libtool ]; then - # m4/glpk-check.m4 is funny... it requires libtool before - # libtool is created. - cp "$(which libtool)" ./; -fi; %configure --enable-shared --disable-static \ - --includedir="%_includedir/pkg/%name" + --includedir="%_includedir/pkg/%name" --docdir="%_docdir/%name" make %{?_smp_mflags}; %install b="%buildroot"; make install DESTDIR="$b"; +cp doc/* "$b/%_docdir/%name/" rm -f "$b/%_libdir"/*.la; mkdir -p "$b/%_bindir" "$b/%_libexecdir/%name"; mv "$b/%_bindir"/* "$b/%_libexecdir/%name/"; pushd "$b/%_libexecdir/%name"; -for i in 4ti2*; do - ln -s "%_libexecdir/%name/$i" "$b/%_bindir/$i"; +for i in *; do + ln -s "%_libexecdir/%name/$i" "$b/%_bindir/4ti2_$i"; done; %post -n lib4ti2-0 -p /sbin/ldconfig @@ -106,14 +99,16 @@ done; %files %defattr(-,root,root) %_bindir/4ti2* -%_libexecdir/%name -%doc COPYING doc/* +%_libexecdir/%name/ +%_docdir/%name/ %files -n lib4ti2-0 %defattr(-,root,root) %_libdir/lib4ti2gmp.so.0* %_libdir/lib4ti2int32.so.0* %_libdir/lib4ti2int64.so.0* +%_libdir/lib4ti2common.so.0* +%_libdir/lib4ti2util.so.0* %files -n libzsolve0 %defattr(-,root,root)