diff --git a/cpp/include/cuopt/linear_programming/constants.h b/cpp/include/cuopt/linear_programming/constants.h index b512944a6..faaf1b9a3 100644 --- a/cpp/include/cuopt/linear_programming/constants.h +++ b/cpp/include/cuopt/linear_programming/constants.h @@ -20,47 +20,54 @@ #define CUOPT_INSTANTIATE_INT64 0 /* @brief LP/MIP parameter string constants */ -#define CUOPT_ABSOLUTE_DUAL_TOLERANCE "absolute_dual_tolerance" -#define CUOPT_RELATIVE_DUAL_TOLERANCE "relative_dual_tolerance" -#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE "absolute_primal_tolerance" -#define CUOPT_RELATIVE_PRIMAL_TOLERANCE "relative_primal_tolerance" -#define CUOPT_ABSOLUTE_GAP_TOLERANCE "absolute_gap_tolerance" -#define CUOPT_RELATIVE_GAP_TOLERANCE "relative_gap_tolerance" -#define CUOPT_INFEASIBILITY_DETECTION "infeasibility_detection" -#define CUOPT_STRICT_INFEASIBILITY "strict_infeasibility" -#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE "primal_infeasible_tolerance" -#define CUOPT_DUAL_INFEASIBLE_TOLERANCE "dual_infeasible_tolerance" -#define CUOPT_ITERATION_LIMIT "iteration_limit" -#define CUOPT_TIME_LIMIT "time_limit" -#define CUOPT_PDLP_SOLVER_MODE "pdlp_solver_mode" -#define CUOPT_METHOD "method" -#define CUOPT_PER_CONSTRAINT_RESIDUAL "per_constraint_residual" -#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR "save_best_primal_so_far" -#define CUOPT_FIRST_PRIMAL_FEASIBLE "first_primal_feasible" -#define CUOPT_LOG_FILE "log_file" -#define CUOPT_LOG_TO_CONSOLE "log_to_console" -#define CUOPT_CROSSOVER "crossover" -#define CUOPT_FOLDING "folding" -#define CUOPT_AUGMENTED "augmented" -#define CUOPT_DUALIZE "dualize" -#define CUOPT_ORDERING "ordering" -#define CUOPT_BARRIER_DUAL_INITIAL_POINT "barrier_dual_initial_point" -#define CUOPT_ELIMINATE_DENSE_COLUMNS "eliminate_dense_columns" -#define CUOPT_CUDSS_DETERMINISTIC "cudss_deterministic" -#define CUOPT_PRESOLVE "presolve" -#define CUOPT_DUAL_POSTSOLVE "dual_postsolve" -#define CUOPT_MIP_ABSOLUTE_TOLERANCE "mip_absolute_tolerance" -#define CUOPT_MIP_RELATIVE_TOLERANCE "mip_relative_tolerance" -#define CUOPT_MIP_INTEGRALITY_TOLERANCE "mip_integrality_tolerance" -#define CUOPT_MIP_ABSOLUTE_GAP "mip_absolute_gap" -#define CUOPT_MIP_RELATIVE_GAP "mip_relative_gap" -#define CUOPT_MIP_HEURISTICS_ONLY "mip_heuristics_only" -#define CUOPT_MIP_SCALING "mip_scaling" -#define CUOPT_MIP_PRESOLVE "mip_presolve" -#define CUOPT_SOLUTION_FILE "solution_file" -#define CUOPT_NUM_CPU_THREADS "num_cpu_threads" -#define CUOPT_NUM_GPUS "num_gpus" -#define CUOPT_USER_PROBLEM_FILE "user_problem_file" +#define CUOPT_ABSOLUTE_DUAL_TOLERANCE "absolute_dual_tolerance" +#define CUOPT_RELATIVE_DUAL_TOLERANCE "relative_dual_tolerance" +#define CUOPT_ABSOLUTE_PRIMAL_TOLERANCE "absolute_primal_tolerance" +#define CUOPT_RELATIVE_PRIMAL_TOLERANCE "relative_primal_tolerance" +#define CUOPT_ABSOLUTE_GAP_TOLERANCE "absolute_gap_tolerance" +#define CUOPT_RELATIVE_GAP_TOLERANCE "relative_gap_tolerance" +#define CUOPT_INFEASIBILITY_DETECTION "infeasibility_detection" +#define CUOPT_STRICT_INFEASIBILITY "strict_infeasibility" +#define CUOPT_PRIMAL_INFEASIBLE_TOLERANCE "primal_infeasible_tolerance" +#define CUOPT_DUAL_INFEASIBLE_TOLERANCE "dual_infeasible_tolerance" +#define CUOPT_ITERATION_LIMIT "iteration_limit" +#define CUOPT_TIME_LIMIT "time_limit" +#define CUOPT_PDLP_SOLVER_MODE "pdlp_solver_mode" +#define CUOPT_METHOD "method" +#define CUOPT_PER_CONSTRAINT_RESIDUAL "per_constraint_residual" +#define CUOPT_SAVE_BEST_PRIMAL_SO_FAR "save_best_primal_so_far" +#define CUOPT_FIRST_PRIMAL_FEASIBLE "first_primal_feasible" +#define CUOPT_LOG_FILE "log_file" +#define CUOPT_LOG_TO_CONSOLE "log_to_console" +#define CUOPT_CROSSOVER "crossover" +#define CUOPT_FOLDING "folding" +#define CUOPT_AUGMENTED "augmented" +#define CUOPT_DUALIZE "dualize" +#define CUOPT_ORDERING "ordering" +#define CUOPT_BARRIER_DUAL_INITIAL_POINT "barrier_dual_initial_point" +#define CUOPT_ELIMINATE_DENSE_COLUMNS "eliminate_dense_columns" +#define CUOPT_CUDSS_DETERMINISTIC "cudss_deterministic" +#define CUOPT_PRESOLVE "presolve" +#define CUOPT_DUAL_POSTSOLVE "dual_postsolve" +#define CUOPT_MIP_ABSOLUTE_TOLERANCE "mip_absolute_tolerance" +#define CUOPT_MIP_RELATIVE_TOLERANCE "mip_relative_tolerance" +#define CUOPT_MIP_INTEGRALITY_TOLERANCE "mip_integrality_tolerance" +#define CUOPT_MIP_ABSOLUTE_GAP "mip_absolute_gap" +#define CUOPT_MIP_RELATIVE_GAP "mip_relative_gap" +#define CUOPT_MIP_HEURISTICS_ONLY "mip_heuristics_only" +#define CUOPT_MIP_SCALING "mip_scaling" +#define CUOPT_MIP_PRESOLVE "mip_presolve" +#define CUOPT_MIP_CUT_PASSES "mip_cut_passes" +#define CUOPT_MIP_MIR_CUTS "mip_mir_cuts" +#define CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS "mip_mixed_integer_gomory_cuts" +#define CUOPT_MIP_KNAPSACK_CUTS "mip_knapsack_cuts" +#define CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS "mip_strong_chvatal_gomory_cuts" +#define CUOPT_MIP_NODE_LIMIT "mip_node_limit" +#define CUOPT_MIP_RELIABILITY_BRANCHING "mip_reliability_branching" +#define CUOPT_SOLUTION_FILE "solution_file" +#define CUOPT_NUM_CPU_THREADS "num_cpu_threads" +#define CUOPT_NUM_GPUS "num_gpus" +#define CUOPT_USER_PROBLEM_FILE "user_problem_file" /* @brief LP/MIP termination status constants */ #define CUOPT_TERIMINATION_STATUS_NO_TERMINATION 0 diff --git a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp b/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp index 4f6320752..34d472ca7 100644 --- a/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp +++ b/cpp/include/cuopt/linear_programming/mip/solver_settings.hpp @@ -79,8 +79,15 @@ class mip_solver_settings_t { tolerances_t tolerances; f_t time_limit = std::numeric_limits::infinity(); + i_t node_limit = std::numeric_limits::max(); + i_t reliability_branching = -1; bool heuristics_only = false; i_t num_cpu_threads = -1; // -1 means use default number of threads in branch and bound + i_t max_cut_passes = 0; // number of cut passes to make + i_t mir_cuts = -1; + i_t mixed_integer_gomory_cuts = -1; + i_t knapsack_cuts = -1; + i_t strong_chvatal_gomory_cuts = -1; i_t num_gpus = 1; bool log_to_console = true; std::string log_file; diff --git a/cpp/src/dual_simplex/CMakeLists.txt b/cpp/src/dual_simplex/CMakeLists.txt index af1415fa9..76312c49d 100644 --- a/cpp/src/dual_simplex/CMakeLists.txt +++ b/cpp/src/dual_simplex/CMakeLists.txt @@ -10,6 +10,7 @@ set(DUAL_SIMPLEX_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/basis_updates.cpp ${CMAKE_CURRENT_SOURCE_DIR}/bound_flipping_ratio_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/branch_and_bound.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/cuts.cpp ${CMAKE_CURRENT_SOURCE_DIR}/crossover.cpp ${CMAKE_CURRENT_SOURCE_DIR}/folding.cpp ${CMAKE_CURRENT_SOURCE_DIR}/initial_basis.cpp @@ -35,7 +36,7 @@ set(DUAL_SIMPLEX_SRC_FILES ) # Uncomment to enable debug info -#set_source_files_properties(${DUAL_SIMPLEX_SRC_FILES} DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTIES COMPILE_OPTIONS "-g1") +set_source_files_properties(${DUAL_SIMPLEX_SRC_FILES} DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTIES COMPILE_OPTIONS "-g1") set(CUOPT_SRC_FILES ${CUOPT_SRC_FILES} ${DUAL_SIMPLEX_SRC_FILES} PARENT_SCOPE) diff --git a/cpp/src/dual_simplex/basis_solves.cpp b/cpp/src/dual_simplex/basis_solves.cpp index f5cd54053..7b0eb150a 100644 --- a/cpp/src/dual_simplex/basis_solves.cpp +++ b/cpp/src/dual_simplex/basis_solves.cpp @@ -363,7 +363,7 @@ i_t factorize_basis(const csc_matrix_t& A, S_perm_inv); if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { settings.log.printf("Concurrent halt\n"); - return -1; + return -2; } if (Srank != Sdim) { // Get the rank deficient columns @@ -582,7 +582,7 @@ i_t factorize_basis(const csc_matrix_t& A, } if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { settings.log.printf("Concurrent halt\n"); - return -1; + return -2; } if (verbose) { printf("Right Lnz+Unz %d t %.3f\n", L.col_start[m] + U.col_start[m], toc(fact_start)); diff --git a/cpp/src/dual_simplex/basis_updates.cpp b/cpp/src/dual_simplex/basis_updates.cpp index 2c781a515..64d08d87a 100644 --- a/cpp/src/dual_simplex/basis_updates.cpp +++ b/cpp/src/dual_simplex/basis_updates.cpp @@ -1108,6 +1108,212 @@ i_t basis_update_t::lower_triangular_multiply(const csc_matrix_t +i_t basis_update_mpf_t::append_cuts(const csr_matrix_t& cuts_basic) +{ + const i_t m = L0_.m; + + // Solve for U^T W^T = C_B^T + // We do this one row at a time of C_B + csc_matrix_t WT(m, cuts_basic.m, 0); + + i_t WT_nz = 0; + for (i_t k = 0; k < cuts_basic.m; k++) { + sparse_vector_t rhs(cuts_basic, k); + u_transpose_solve(rhs); + WT.col_start[k] = WT_nz; + for (i_t q = 0; q < rhs.i.size(); q++) { + WT.i.push_back(rhs.i[q]); + WT.x.push_back(rhs.x[q]); + WT_nz++; + } + } + WT.col_start[cuts_basic.m] = WT_nz; + + +#ifdef CHECK_W + { + for (i_t k = 0; k < cuts_basic.m; k++) { + std::vector WT_col(m, 0.0); + WT.load_a_column(k, WT_col); + std::vector CBT_col(m, 0.0); + matrix_transpose_vector_multiply(U0_, 1.0, WT_col, 0.0, CBT_col); + sparse_vector_t CBT_col_sparse(cuts_basic, k); + std::vector CBT_col_dense(m); + CBT_col_sparse.to_dense(CBT_col_dense); + for (i_t h = 0; h < m; h++) { + if (std::abs(CBT_col_dense[h] - CBT_col[h]) > 1e-6) { + printf("W: col %d CBT_col_dense[%d] = %e CBT_col[%d] = %e\n", k, h, CBT_col_dense[h], h, CBT_col[h]); + exit(1); + } + } + } + } +#endif + + csc_matrix_t V(cuts_basic.m, m, 0); + if (num_updates_ > 0) { + // W = V T_0 ... T_{num_updates_ - 1} + // or V = W T_{num_updates_ - 1}^{-1} ... T_0^{-1} + // or V^T = T_0^{-T} ... T_{num_updates_ - 1}^{-T} W^T + // We can compute V^T column by column so that we have + // V^T(:, h) = T_0^{-T} ... T_{num_updates_ - 1}^{-T} W^T(:, h) + // or + // V(h, :) = T_0^{-T} ... T_{num_updates_ - 1}^{-T} W^T(:, h) + // So we can form V row by row in CSR and then covert it to CSC + // for appending to L0 + + csr_matrix_t V_row(cuts_basic.m, m, 0); + i_t V_nz = 0; + const f_t zero_tol = 1e-13; + for (i_t h = 0; h < cuts_basic.m; h++) { + sparse_vector_t rhs(WT, h); + scatter_into_workspace(rhs); + i_t nz = rhs.i.size(); + for (i_t k = num_updates_ - 1; k >= 0; --k) { + // T_k^{-T} = ( I - v u^T/(1 + u^T v)) + // T_k^{-T} * b = b - v * (u^T * b) / (1 + u^T * v) = b - theta * v, theta = u^T b / mu + + const i_t u_col = 2 * k; + const i_t v_col = 2 * k + 1; + const f_t mu = mu_values_[k]; + + // dot = u^T * b + f_t dot = dot_product(u_col, xi_workspace_, x_workspace_); + const f_t theta = dot / mu; + if (std::abs(theta) > zero_tol) { + add_sparse_column(S_, v_col, -theta, xi_workspace_, nz, x_workspace_); + } + } + gather_into_sparse_vector(nz, rhs); + V_row.row_start[h] = V_nz; + for (i_t q = 0; q < rhs.i.size(); q++) { + V_row.j.push_back(rhs.i[q]); + V_row.x.push_back(rhs.x[q]); + V_nz++; + } + } + V_row.row_start[cuts_basic.m] = V_nz; + + V_row.to_compressed_col(V); + + +#ifdef CHECK_V + csc_matrix_t CB_col(cuts_basic.m, m, 0); + cuts_basic.to_compressed_col(CB_col); + for (i_t k = 0; k < m; k++) { + std::vector U_col(m, 0.0); + U0_.load_a_column(k, U_col); + for (i_t h = num_updates_ - 1; h >= 0; --h) { + // T_h = ( I + u_h v_h^T) + // T_h * x = x + u_h * v_h^T * x = x + theta * u_h + const i_t u_col = 2 * h; + const i_t v_col = 2 * h + 1; + f_t theta = dot_product(v_col, U_col); + const i_t col_start = S_.col_start[u_col]; + const i_t col_end = S_.col_start[u_col + 1]; + for (i_t p = col_start; p < col_end; ++p) { + const i_t i = S_.i[p]; + U_col[i] += theta * S_.x[p]; + } + } + std::vector CB_column(cuts_basic.m, 0.0); + matrix_vector_multiply(V, 1.0, U_col, 0.0, CB_column); + std::vector CB_col_dense(cuts_basic.m); + CB_col.load_a_column(k, CB_col_dense); + for (i_t l = 0; l < cuts_basic.m; l++) { + if (std::abs(CB_col_dense[l] - CB_column[l]) > 1e-6) { + printf("V: col %d CB_col_dense[%d] = %e CB_column[%d] = %e\n", k, l, CB_col_dense[l], l, CB_column[l]); + exit(1); + } + } + } +#endif + } else { + // W = V + WT.transpose(V); + } + + // Extend u_i, v_i for i = 0, ..., num_updates_ - 1 + S_.m += cuts_basic.m; + + // Adjust L and U + // L = [ L0 0 ] + // [ V I ] + + i_t V_nz = V.col_start[m]; + i_t L_nz = L0_.col_start[m]; + csc_matrix_t new_L(m + cuts_basic.m, m + cuts_basic.m, L_nz + V_nz + cuts_basic.m); + i_t predicted_nz = L_nz + V_nz + cuts_basic.m; + L_nz = 0; + for (i_t j = 0; j < m; ++j) { + new_L.col_start[j] = L_nz; + const i_t col_start = L0_.col_start[j]; + const i_t col_end = L0_.col_start[j + 1]; + for (i_t p = col_start; p < col_end; ++p) { + new_L.i[L_nz] = L0_.i[p]; + new_L.x[L_nz] = L0_.x[p]; + L_nz++; + } + const i_t V_col_start = V.col_start[j]; + const i_t V_col_end = V.col_start[j + 1]; + for (i_t p = V_col_start; p < V_col_end; ++p) { + new_L.i[L_nz] = V.i[p] + m; + new_L.x[L_nz] = V.x[p]; + L_nz++; + } + } + for (i_t j = m; j < m + cuts_basic.m; ++j) { + new_L.col_start[j] = L_nz; + new_L.i[L_nz] = j; + new_L.x[L_nz] = 1.0; + L_nz++; + } + new_L.col_start[m + cuts_basic.m] = L_nz; + if (L_nz != predicted_nz) { + printf("L_nz %d predicted_nz %d\n", L_nz, predicted_nz); + assert(L_nz == predicted_nz); + } + + L0_ = new_L; + + // Adjust U + // U = [ U0 0 ] + // [ 0 I ] + + i_t U_nz = U0_.col_start[m]; + U0_.col_start.resize(m + cuts_basic.m + 1); + U0_.i.resize(U_nz + cuts_basic.m); + U0_.x.resize(U_nz + cuts_basic.m); + for (i_t k = m; k < m + cuts_basic.m; ++k) { + U0_.col_start[k] = U_nz; + U0_.i[U_nz] = k; + U0_.x[U_nz] = 1.0; + U_nz++; + } + U0_.col_start[m + cuts_basic.m] = U_nz; + U0_.n = m + cuts_basic.m; + U0_.m = m + cuts_basic.m; + + compute_transposes(); + + // Adjust row_permutation_ and inverse_row_permutation_ + row_permutation_.resize(m + cuts_basic.m); + inverse_row_permutation_.resize(m + cuts_basic.m); + for (i_t k = m; k < m + cuts_basic.m; ++k) { + row_permutation_[k] = k; + } + inverse_permutation(row_permutation_, inverse_row_permutation_); + + // Adjust workspace sizes + xi_workspace_.resize(2 * (m + cuts_basic.m), 0); + x_workspace_.resize(m + cuts_basic.m, 0.0); + + return 0; +} + template void basis_update_mpf_t::gather_into_sparse_vector(i_t nz, sparse_vector_t& out) const @@ -2057,7 +2263,7 @@ int basis_update_mpf_t::refactor_basis( if (L0_.m != A.m) { resize(A.m); } std::vector q; - if (factorize_basis(A, + i_t status = factorize_basis(A, settings, basic_list, L0_, @@ -2066,7 +2272,11 @@ int basis_update_mpf_t::refactor_basis( inverse_row_permutation_, q, deficient, - slacks_needed) == -1) { + slacks_needed); + if (status == -2) { + return -2; + } + if (status == -1) { settings.log.debug("Initial factorization failed\n"); basis_repair( A, settings, lower, upper, deficient, slacks_needed, basic_list, nonbasic_list, vstatus); @@ -2088,7 +2298,7 @@ int basis_update_mpf_t::refactor_basis( } #endif - if (factorize_basis(A, + status = factorize_basis(A, settings, basic_list, L0_, @@ -2097,7 +2307,9 @@ int basis_update_mpf_t::refactor_basis( inverse_row_permutation_, q, deficient, - slacks_needed) == -1) { + slacks_needed); + if (status == -2) { return -2; } + if (status == -1) { #ifdef CHECK_L_FACTOR if (L0_.check_matrix() == -1) { settings.log.printf("Bad L after basis repair\n"); } #endif diff --git a/cpp/src/dual_simplex/basis_updates.hpp b/cpp/src/dual_simplex/basis_updates.hpp index afd4f4c9a..8eca3ba8a 100644 --- a/cpp/src/dual_simplex/basis_updates.hpp +++ b/cpp/src/dual_simplex/basis_updates.hpp @@ -291,6 +291,8 @@ class basis_update_mpf_t { reset_stats(); } + i_t append_cuts(const csr_matrix_t& cuts_basic); + f_t estimate_solution_density(f_t rhs_nz, f_t sum, i_t& num_calls, bool& use_hypersparse) const { num_calls++; diff --git a/cpp/src/dual_simplex/branch_and_bound.cpp b/cpp/src/dual_simplex/branch_and_bound.cpp index b2c9f85d2..676cdface 100644 --- a/cpp/src/dual_simplex/branch_and_bound.cpp +++ b/cpp/src/dual_simplex/branch_and_bound.cpp @@ -7,6 +7,8 @@ #include +#include +#include #include #include #include @@ -225,7 +227,8 @@ inline char feasible_solution_symbol(bnb_worker_type_t type) template branch_and_bound_t::branch_and_bound_t( const user_problem_t& user_problem, - const simplex_solver_settings_t& solver_settings) + const simplex_solver_settings_t& solver_settings, + f_t start_time) : original_problem_(user_problem), settings_(solver_settings), original_lp_(user_problem.handle_ptr, 1, 1, 1), @@ -236,11 +239,43 @@ branch_and_bound_t::branch_and_bound_t( pc_(1), solver_status_(mip_status_t::UNSET) { - exploration_stats_.start_time = tic(); + exploration_stats_.start_time = start_time; +#ifdef PRINT_CONSTRAINT_MATRIX + settings_.log.printf("A"); + original_problem_.A.print_matrix(); +#endif + dualize_info_t dualize_info; convert_user_problem(original_problem_, settings_, original_lp_, new_slacks_, dualize_info); full_variable_types(original_problem_, original_lp_, var_types_); + num_integer_variables_ = 0; + for (i_t j = 0; j < original_lp_.num_cols; j++) { + if (var_types_[j] == variable_type_t::INTEGER) { + num_integer_variables_++; + } + } + + // Check slack +#ifdef CHECK_SLACKS + assert(new_slacks_.size() == original_lp_.num_rows); + for (i_t slack : new_slacks_) { + const i_t col_start = original_lp_.A.col_start[slack]; + const i_t col_end = original_lp_.A.col_start[slack + 1]; + const i_t col_len = col_end - col_start; + if (col_len != 1) { + settings_.log.printf("Slack %d has %d nzs\n", slack, col_len); + assert(col_len == 1); + } + const i_t i = original_lp_.A.i[col_start]; + const f_t x = original_lp_.A.x[col_start]; + if (std::abs(x) != 1.0) { + settings_.log.printf("Slack %d row %d has non-unit coefficient %e\n", slack, i, x); + assert(std::abs(x) == 1.0); + } + } +#endif + upper_bound_ = inf; } @@ -267,7 +302,7 @@ void branch_and_bound_t::report_heuristic(f_t obj) std::string user_gap = user_mip_gap(user_obj, user_lower); settings_.log.printf( - "H %+13.6e %+10.6e %s %9.2f\n", + "H %+13.6e %+10.6e %s %9.2f\n", user_obj, user_lower, user_gap.c_str(), @@ -280,7 +315,7 @@ void branch_and_bound_t::report_heuristic(f_t obj) } template -void branch_and_bound_t::report(char symbol, f_t obj, f_t lower_bound, i_t node_depth) +void branch_and_bound_t::report(char symbol, f_t obj, f_t lower_bound, i_t node_depth, i_t node_int_infeas) { i_t nodes_explored = exploration_stats_.nodes_explored; i_t nodes_unexplored = exploration_stats_.nodes_unexplored; @@ -288,21 +323,104 @@ void branch_and_bound_t::report(char symbol, f_t obj, f_t lower_bound, f_t user_lower = compute_user_objective(original_lp_, lower_bound); f_t iter_node = exploration_stats_.total_lp_iters / nodes_explored; std::string user_gap = user_mip_gap(user_obj, user_lower); - settings_.log.printf("%c %10d %10lu %+13.6e %+10.6e %6d %7.1e %s %9.2f\n", + settings_.log.printf("%c %10d %10lu %+13.6e %+10.6e %6d %6d %7.1e %s %9.2f\n", symbol, nodes_explored, nodes_unexplored, user_obj, user_lower, + node_int_infeas, node_depth, iter_node, user_gap.c_str(), toc(exploration_stats_.start_time)); } +template +void branch_and_bound_t::find_reduced_cost_fixings(f_t upper_bound) +{ + mutex_original_lp_.lock(); + std::vector reduced_costs = root_relax_soln_.z; + std::vector lower_bounds = original_lp_.lower; + std::vector upper_bounds = original_lp_.upper; + std::vector bounds_changed(original_lp_.num_cols, false); + const f_t root_obj = compute_objective(original_lp_, root_relax_soln_.x); + const f_t threshold = 1e-3; + const f_t weaken = 1e-5; + i_t num_improved = 0; + i_t num_fixed = 0; + for (i_t j = 0; j < original_lp_.num_cols; j++) { + //printf("Variable %d type %d reduced cost %e\n", j, var_types_[j], reduced_costs[j]); + if (std::abs(reduced_costs[j]) > threshold) { + const f_t lower_j = original_lp_.lower[j]; + const f_t upper_j = original_lp_.upper[j]; + const f_t abs_gap = upper_bound - root_obj; + f_t reduced_cost_upper_bound = upper_j; + f_t reduced_cost_lower_bound = lower_j; + if (lower_j > -inf && reduced_costs[j] > 0) + { + const f_t new_upper_bound = lower_j + abs_gap/reduced_costs[j]; + reduced_cost_upper_bound = var_types_[j] == variable_type_t::INTEGER + ? std::floor(new_upper_bound + weaken) + : new_upper_bound; + if (reduced_cost_upper_bound < upper_j) { + //printf("Improved upper bound for variable %d from %e to %e (%e)\n", j, upper_j, reduced_cost_upper_bound, new_upper_bound); + num_improved++; + upper_bounds[j] = reduced_cost_upper_bound; + bounds_changed[j] = true; + } + } + if (upper_j < inf && reduced_costs[j] < 0) + { + const f_t new_lower_bound = upper_j + abs_gap/reduced_costs[j]; + reduced_cost_lower_bound = var_types_[j] == variable_type_t::INTEGER + ? std::ceil(new_lower_bound - weaken) + : new_lower_bound; + if (reduced_cost_lower_bound > lower_j) { + //printf("Improved lower bound for variable %d from %e to %e (%e)\n", j, lower_j, reduced_cost_lower_bound, new_lower_bound); + num_improved++; + lower_bounds[j] = reduced_cost_lower_bound; + bounds_changed[j] = true; + } + } + if (var_types_[j] == variable_type_t::INTEGER && reduced_cost_upper_bound <= reduced_cost_lower_bound) + { + num_fixed++; + } + } + } + + if (num_fixed > 0) { + printf("Reduced costs: Found %d improved bounds and %d fixed variables (%.1f%%)\n", num_improved, num_fixed, 100.0*static_cast(num_fixed)/static_cast(num_integer_variables_)); + } + + if (num_improved > 0) { + lp_problem_t new_lp = original_lp_; + new_lp.lower = lower_bounds; + new_lp.upper = upper_bounds; + std::vector row_sense; + csr_matrix_t Arow(1, 1, 1); + original_lp_.A.to_compressed_row(Arow); + bounds_strengthening_t node_presolve(new_lp, Arow, row_sense, var_types_); + bool feasible = node_presolve.bounds_strengthening(new_lp.lower, new_lp.upper, settings_); + + i_t bnd_num_improved = 0; + for (i_t j = 0; j < original_lp_.num_cols; j++) { + if (new_lp.lower[j] > original_lp_.lower[j]) { bnd_num_improved++; } + if (new_lp.upper[j] < original_lp_.upper[j]) { bnd_num_improved++; } + } + if (bnd_num_improved != num_improved) { + printf("Bound strengthening: Found %d improved bounds\n", bnd_num_improved); + } + } + + mutex_original_lp_.unlock(); +} + template void branch_and_bound_t::set_new_solution(const std::vector& solution) { + mutex_original_lp_.lock(); if (solution.size() != original_problem_.num_cols) { settings_.log.printf( "Solution size mismatch %ld %d\n", solution.size(), original_problem_.num_cols); @@ -311,16 +429,22 @@ void branch_and_bound_t::set_new_solution(const std::vector& solu crush_primal_solution( original_problem_, original_lp_, solution, new_slacks_, crushed_solution); f_t obj = compute_objective(original_lp_, crushed_solution); + mutex_original_lp_.unlock(); bool is_feasible = false; bool attempt_repair = false; mutex_upper_.lock(); - if (obj < upper_bound_) { + f_t current_upper_bound = upper_bound_; + mutex_upper_.unlock(); + if (obj < current_upper_bound) { f_t primal_err; f_t bound_err; i_t num_fractional; + mutex_original_lp_.lock(); is_feasible = check_guess( original_lp_, settings_, var_types_, crushed_solution, primal_err, bound_err, num_fractional); - if (is_feasible) { + mutex_original_lp_.unlock(); + mutex_upper_.lock(); + if (is_feasible && obj < upper_bound_) { upper_bound_ = obj; incumbent_.set_incumbent_solution(obj, crushed_solution); } else { @@ -335,8 +459,8 @@ void branch_and_bound_t::set_new_solution(const std::vector& solu num_fractional); } } + mutex_upper_.unlock(); } - mutex_upper_.unlock(); if (is_feasible) { report_heuristic(obj); } if (attempt_repair) { @@ -441,6 +565,8 @@ void branch_and_bound_t::repair_heuristic_solutions() uncrush_primal_solution(original_problem_, original_lp_, repaired_solution, original_x); settings_.solution_callback(original_x, repaired_obj); } + + find_reduced_cost_fixings(repaired_obj); } mutex_upper_.unlock(); @@ -449,6 +575,35 @@ void branch_and_bound_t::repair_heuristic_solutions() } } +template +void branch_and_bound_t::set_solution_at_root(mip_solution_t& solution, + const cut_info_t& cut_info) +{ + mutex_upper_.lock(); + incumbent_.set_incumbent_solution(root_objective_, root_relax_soln_.x); + upper_bound_ = root_objective_; + mutex_upper_.unlock(); + + print_cut_info(settings_, cut_info); + + // We should be done here + uncrush_primal_solution(original_problem_, original_lp_, incumbent_.x, solution.x); + solution.objective = incumbent_.objective; + solution.lower_bound = root_objective_; + solution.nodes_explored = 0; + solution.simplex_iterations = root_relax_soln_.iterations; + settings_.log.printf("Optimal solution found at root node. Objective %.16e. Time %.2f.\n", + compute_user_objective(original_lp_, root_objective_), + toc(exploration_stats_.start_time)); + + if (settings_.solution_callback != nullptr) { + settings_.solution_callback(solution.x, solution.objective); + } + if (settings_.heuristic_preemption_callback != nullptr) { + settings_.heuristic_preemption_callback(); + } +} + template void branch_and_bound_t::set_final_solution(mip_solution_t& solution, f_t lower_bound) @@ -481,6 +636,34 @@ void branch_and_bound_t::set_final_solution(mip_solution_t& if (gap <= settings_.absolute_mip_gap_tol || gap_rel <= settings_.relative_mip_gap_tol) { solver_status_ = mip_status_t::OPTIMAL; +#if 1 + if (settings_.sub_mip == 0) { + FILE* fid = NULL; + fid = fopen("solution.dat", "w"); + if (fid != NULL) { + printf("Writing solution.dat\n"); + + std::vector residual = original_lp_.rhs; + matrix_vector_multiply(original_lp_.A, 1.0, incumbent_.x, -1.0, residual); + printf("|| A*x - b ||_inf %e\n", vector_norm_inf(residual)); + auto hash_combine_f = [](size_t seed, f_t x) { + seed ^= std::hash{}(x) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + return seed; + }; + printf( + "incumbent size %ld original lp cols %d\n", incumbent_.x.size(), original_lp_.num_cols); + i_t n = original_lp_.num_cols; + size_t seed = n; + fprintf(fid, "%d\n", n); + for (i_t j = 0; j < n; ++j) { + fprintf(fid, "%.17g\n", incumbent_.x[j]); + seed = hash_combine_f(seed, incumbent_.x[j]); + } + printf("Solution hash: %20x\n", seed); + fclose(fid); + } + } +#endif if (gap > 0 && gap <= settings_.absolute_mip_gap_tol) { settings_.log.printf("Optimal solution found within absolute MIP gap tolerance (%.1e)\n", settings_.absolute_mip_gap_tol); @@ -532,7 +715,7 @@ void branch_and_bound_t::add_feasible_solution(f_t leaf_objective, if (leaf_objective < upper_bound_) { incumbent_.set_incumbent_solution(leaf_objective, leaf_solution); upper_bound_ = leaf_objective; - report(feasible_solution_symbol(thread_type), leaf_objective, get_lower_bound(), leaf_depth); + report(feasible_solution_symbol(thread_type), leaf_objective, get_lower_bound(), leaf_depth, 0); send_solution = true; } @@ -616,6 +799,7 @@ dual::status_t branch_and_bound_t::solve_node_lp( mip_node_t* node_ptr, lp_problem_t& leaf_problem, lp_solution_t& leaf_solution, + std::vector& leaf_edge_norms, basis_update_mpf_t& basis_factors, std::vector& basic_list, std::vector& nonbasic_list, @@ -627,6 +811,34 @@ dual::status_t branch_and_bound_t::solve_node_lp( bnb_stats_t& stats, logger_t& log) { + + if (node_ptr->depth > num_integer_variables_) { + std::vector branched_variables(original_lp_.num_cols, 0); + std::vector branched_lower(original_lp_.num_cols, std::numeric_limits::quiet_NaN()); + std::vector branched_upper(original_lp_.num_cols, std::numeric_limits::quiet_NaN()); + mip_node_t* parent = node_ptr->parent; + while (parent != nullptr) { + if (original_lp_.lower[parent->branch_var] != 0.0 || original_lp_.upper[parent->branch_var] != 1.0) { + break; + } + if (branched_variables[parent->branch_var] == 1) { + printf( + "Variable %d already branched. Previous lower %e upper %e. Current lower %e upper %e.\n", + parent->branch_var, + branched_lower[parent->branch_var], + branched_upper[parent->branch_var], + parent->branch_var_lower, + parent->branch_var_upper); + } + branched_variables[parent->branch_var] = 1; + branched_lower[parent->branch_var] = parent->branch_var_lower; + branched_upper[parent->branch_var] = parent->branch_var_upper; + parent = parent->parent; + } + if (parent == nullptr) { + printf("Depth %d > num_integer_variables %d\n", node_ptr->depth, num_integer_variables_); + } + } std::vector& leaf_vstatus = node_ptr->vstatus; assert(leaf_vstatus.size() == leaf_problem.num_cols); @@ -687,10 +899,10 @@ dual::status_t branch_and_bound_t::solve_node_lp( dual::status_t lp_status = dual::status_t::DUAL_UNBOUNDED; + if (feasible) { i_t node_iter = 0; f_t lp_start_time = tic(); - std::vector leaf_edge_norms = edge_norms_; // = node.steepest_edge_norms; lp_status = dual_phase2_with_advanced_basis(2, 0, @@ -738,6 +950,7 @@ std::pair branch_and_bound_t::upd search_tree_t& search_tree, lp_problem_t& leaf_problem, lp_solution_t& leaf_solution, + std::vector& leaf_edge_norms, bnb_worker_type_t thread_type, dual::status_t lp_status, logger_t& log) @@ -766,6 +979,23 @@ std::pair branch_and_bound_t::upd i_t leaf_num_fractional = fractional_variables(settings_, leaf_solution.x, var_types_, leaf_fractional); + // Check if any of the fractional variables were fixed to their bounds + for (i_t j : leaf_fractional) + { + if (leaf_problem.lower[j] == leaf_problem.upper[j]) + { + printf( + "Node %d: Fixed variable %d has a fractional value %e. Lower %e upper %e. Variable status %d\n", + node_ptr->node_id, + j, + leaf_solution.x[j], + leaf_problem.lower[j], + leaf_problem.upper[j], + leaf_vstatus[j]); + } + } + + f_t leaf_objective = compute_objective(leaf_problem, leaf_solution.x); node_ptr->lower_bound = leaf_objective; search_tree.graphviz_node(log, node_ptr, "lower bound", leaf_objective); @@ -806,7 +1036,7 @@ std::pair branch_and_bound_t::upd } search_tree.branch( - node_ptr, branch_var, leaf_solution.x[branch_var], leaf_vstatus, leaf_problem, log); + node_ptr, branch_var, leaf_solution.x[branch_var], leaf_num_fractional, leaf_vstatus, leaf_problem, log); search_tree.update(node_ptr, node_status_t::HAS_CHILDREN); return {node_status_t::HAS_CHILDREN, round_dir}; @@ -867,7 +1097,7 @@ void branch_and_bound_t::exploration_ramp_up(mip_node_t* nod bool should_report = should_report_.exchange(false); if (should_report) { - report(' ', upper_bound, root_objective_, node->depth); + report(' ', upper_bound, root_objective_, node->depth, node->integer_infeasible); exploration_stats_.nodes_since_last_log = 0; exploration_stats_.last_log = tic(); should_report_ = true; @@ -890,9 +1120,11 @@ void branch_and_bound_t::exploration_ramp_up(mip_node_t* nod std::vector nonbasic_list; lp_solution_t leaf_solution(leaf_problem.num_rows, leaf_problem.num_cols); + std::vector leaf_edge_norms = edge_norms_; // = node.steepest_edge_norms; dual::status_t lp_status = solve_node_lp(node, leaf_problem, leaf_solution, + leaf_edge_norms, basis_factors, basic_list, nonbasic_list, @@ -916,6 +1148,7 @@ void branch_and_bound_t::exploration_ramp_up(mip_node_t* nod search_tree_, leaf_problem, leaf_solution, + leaf_edge_norms, bnb_worker_type_t::BEST_FIRST, lp_status, settings_.log); @@ -990,7 +1223,7 @@ void branch_and_bound_t::plunge_from(i_t task_id, abs_gap < 10 * settings_.absolute_mip_gap_tol) && time_since_last_log >= 1) || (time_since_last_log > 30) || now > settings_.time_limit) { - report(' ', upper_bound, get_lower_bound(), node_ptr->depth); + report(' ', upper_bound, get_lower_bound(), node_ptr->depth, node_ptr->integer_infeasible); exploration_stats_.last_log = tic(); exploration_stats_.nodes_since_last_log = 0; } @@ -1006,9 +1239,11 @@ void branch_and_bound_t::plunge_from(i_t task_id, } lp_solution_t leaf_solution(leaf_problem.num_rows, leaf_problem.num_cols); + std::vector leaf_edge_norms = edge_norms_; // = node.steepest_edge_norms; dual::status_t lp_status = solve_node_lp(node_ptr, leaf_problem, leaf_solution, + leaf_edge_norms, basis_factors, basic_list, nonbasic_list, @@ -1035,6 +1270,7 @@ void branch_and_bound_t::plunge_from(i_t task_id, search_tree_, leaf_problem, leaf_solution, + leaf_edge_norms, bnb_worker_type_t::BEST_FIRST, lp_status, settings_.log); @@ -1177,9 +1413,11 @@ void branch_and_bound_t::dive_from(mip_node_t& start_node, if (dive_stats.nodes_explored > diving_node_limit) { break; } lp_solution_t leaf_solution(leaf_problem.num_rows, leaf_problem.num_cols); + std::vector leaf_edge_norms = edge_norms_; // = node.steepest_edge_norms; dual::status_t lp_status = solve_node_lp(node_ptr, leaf_problem, leaf_solution, + leaf_edge_norms, basis_factors, basic_list, nonbasic_list, @@ -1201,7 +1439,7 @@ void branch_and_bound_t::dive_from(mip_node_t& start_node, ++dive_stats.nodes_explored; auto [node_status, round_dir] = - update_tree(node_ptr, dive_tree, leaf_problem, leaf_solution, diving_type, lp_status, log); + update_tree(node_ptr, dive_tree, leaf_problem, leaf_solution, leaf_edge_norms, diving_type, lp_status, log); recompute_bounds_and_basis = node_status != node_status_t::HAS_CHILDREN; if (node_status == node_status_t::HAS_CHILDREN) { @@ -1286,19 +1524,28 @@ void branch_and_bound_t::diving_thread(bnb_worker_type_t diving_type) template lp_status_t branch_and_bound_t::solve_root_relaxation( - simplex_solver_settings_t const& lp_settings) + simplex_solver_settings_t const& lp_settings, + lp_solution_t& root_relax_soln, + std::vector& root_vstatus, + basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& edge_norms) { // Root node path lp_status_t root_status; std::future root_status_future; root_status_future = std::async(std::launch::async, - &solve_linear_program_advanced, + &solve_linear_program_with_advanced_basis, std::ref(original_lp_), exploration_stats_.start_time, std::ref(lp_settings), - std::ref(root_relax_soln_), - std::ref(root_vstatus_), - std::ref(edge_norms_)); + std::ref(root_relax_soln), + std::ref(basis_update), + std::ref(basic_list), + std::ref(nonbasic_list), + std::ref(root_vstatus), + std::ref(edge_norms)); // Wait for the root relaxation solution to be sent by the diversity manager or dual simplex // to finish while (!root_crossover_solution_set_.load(std::memory_order_acquire) && @@ -1345,15 +1592,58 @@ lp_status_t branch_and_bound_t::solve_root_relaxation( // Check if crossover was stopped by dual simplex if (crossover_status == crossover_status_t::OPTIMAL) { set_root_concurrent_halt(1); // Stop dual simplex - root_status = root_status_future.get(); + root_status = root_status_future.get(); // Wait for dual simplex to finish + set_root_concurrent_halt(0); // Clear the concurrent halt flag // Override the root relaxation solution with the crossover solution - root_relax_soln_ = root_crossover_soln_; - root_vstatus_ = crossover_vstatus_; + root_relax_soln = root_crossover_soln_; + root_vstatus = crossover_vstatus_; root_status = lp_status_t::OPTIMAL; + basic_list.clear(); + nonbasic_list.reserve(original_lp_.num_cols - original_lp_.num_rows); + nonbasic_list.clear(); + // Get the basic list and nonbasic list from the vstatus + for (i_t j = 0; j < original_lp_.num_cols; j++) { + if (crossover_vstatus_[j] == variable_status_t::BASIC) { + basic_list.push_back(j); + } else { + nonbasic_list.push_back(j); + } + } + if (basic_list.size() != original_lp_.num_rows) { + settings_.log.printf( + "basic_list size %d != m %d\n", basic_list.size(), original_lp_.num_rows); + assert(basic_list.size() == original_lp_.num_rows); + } + if (nonbasic_list.size() != original_lp_.num_cols - original_lp_.num_rows) { + settings_.log.printf("nonbasic_list size %d != n - m %d\n", + nonbasic_list.size(), + original_lp_.num_cols - original_lp_.num_rows); + assert(nonbasic_list.size() == original_lp_.num_cols - original_lp_.num_rows); + } + // Populate the basis_update from the crossover vstatus + i_t refactor_status = basis_update.refactor_basis(original_lp_.A, + root_crossover_settings, + original_lp_.lower, + original_lp_.upper, + basic_list, + nonbasic_list, + crossover_vstatus_); + if (refactor_status != 0) { + settings_.log.printf("Failed to refactor basis. %d deficient columns.\n", refactor_status); + assert(refactor_status == 0); + root_status = lp_status_t::NUMERICAL_ISSUES; + } + + // Set the edge norms to a default value + edge_norms.resize(original_lp_.num_cols, -1.0); + set_uninitialized_steepest_edge_norms(edge_norms); + settings_.log.printf("Using crossover solution\n"); } else { + settings_.log.printf("Using dual simplex solution\n"); root_status = root_status_future.get(); } } else { + settings_.log.printf("Using dual simplex solution\n"); root_status = root_status_future.get(); } return root_status; @@ -1415,24 +1705,35 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut root_relax_soln_.resize(original_lp_.num_rows, original_lp_.num_cols); settings_.log.printf("Solving LP root relaxation\n"); - - lp_status_t root_status; + i_t original_rows = original_lp_.num_rows; simplex_solver_settings_t lp_settings = settings_; lp_settings.inside_mip = 1; - lp_settings.concurrent_halt = get_root_concurrent_halt(); - // RINS/SUBMIP path + lp_settings.scale_columns = false; + lp_settings.concurrent_halt = get_root_concurrent_halt(); + std::vector basic_list(original_lp_.num_rows); + std::vector nonbasic_list; + basis_update_mpf_t basis_update(original_lp_.num_rows, settings_.refactor_frequency); + lp_status_t root_status; if (!enable_concurrent_lp_root_solve()) { - root_status = solve_linear_program_advanced(original_lp_, - exploration_stats_.start_time, - lp_settings, - root_relax_soln_, - root_vstatus_, - edge_norms_); - + // RINS/SUBMIP path + root_status = solve_linear_program_with_advanced_basis(original_lp_, + exploration_stats_.start_time, + lp_settings, + root_relax_soln_, + basis_update, + basic_list, + nonbasic_list, + root_vstatus_, + edge_norms_); } else { - root_status = solve_root_relaxation(lp_settings); + root_status = solve_root_relaxation(lp_settings, + root_relax_soln_, + root_vstatus_, + basis_update, + basic_list, + nonbasic_list, + edge_norms_); } - exploration_stats_.total_lp_iters = root_relax_soln_.iterations; exploration_stats_.total_lp_solve_time = toc(exploration_stats_.start_time); @@ -1453,12 +1754,16 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut } return mip_status_t::UNBOUNDED; } - if (root_status == lp_status_t::TIME_LIMIT) { solver_status_ = mip_status_t::TIME_LIMIT; set_final_solution(solution, -inf); return solver_status_; } + if (root_status == lp_status_t::NUMERICAL_ISSUES) { + solver_status_ = mip_status_t::NUMERICAL; + set_final_solution(solution, -inf); + return solver_status_; + } assert(root_vstatus_.size() == original_lp_.num_cols); set_uninitialized_steepest_edge_norms(edge_norms_); @@ -1482,31 +1787,261 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut } std::vector fractional; - const i_t num_fractional = + i_t num_fractional = fractional_variables(settings_, root_relax_soln_.x, var_types_, fractional); + cut_info_t cut_info; if (num_fractional == 0) { - mutex_upper_.lock(); - incumbent_.set_incumbent_solution(root_objective_, root_relax_soln_.x); - upper_bound_ = root_objective_; - mutex_upper_.unlock(); - // We should be done here - uncrush_primal_solution(original_problem_, original_lp_, incumbent_.x, solution.x); - solution.objective = incumbent_.objective; - solution.lower_bound = root_objective_; - solution.nodes_explored = 0; - solution.simplex_iterations = root_relax_soln_.iterations; - settings_.log.printf("Optimal solution found at root node. Objective %.16e. Time %.2f.\n", - compute_user_objective(original_lp_, root_objective_), - toc(exploration_stats_.start_time)); + set_solution_at_root(solution, cut_info); + return mip_status_t::OPTIMAL; + } + + is_running = true; + lower_bound_ceiling_ = inf; - if (settings_.solution_callback != nullptr) { - settings_.solution_callback(solution.x, solution.objective); + if (num_fractional != 0) { + settings_.log.printf( + " | Explored | Unexplored | Objective | Bound | IntInf | Depth | Iter/Node | Gap " + "| Time |\n"); + } + + cut_pool_t cut_pool(original_lp_.num_cols, settings_); + cut_generation_t cut_generation(cut_pool, original_lp_, settings_, Arow_, new_slacks_, var_types_); + + std::vector saved_solution; +#if 1 + read_saved_solution_for_cut_verification(original_lp_, settings_, saved_solution); +#endif + + + i_t cut_pool_size = 0; + for (i_t cut_pass = 0; cut_pass < settings_.max_cut_passes; cut_pass++) { + if (num_fractional == 0) { + set_solution_at_root(solution, cut_info); + return mip_status_t::OPTIMAL; + } else { +#ifdef PRINT_FRACTIONAL_INFO + settings_.log.printf("Found %d fractional variables on cut pass %d\n", num_fractional, cut_pass); + for (i_t j: fractional) { + settings_.log.printf("Fractional variable %d lower %e value %e upper %e\n", j, original_lp_.lower[j], root_relax_soln_.x[j], original_lp_.upper[j]); + } +#endif + + // Generate cuts and add them to the cut pool + f_t cut_start_time = tic(); + cut_generation.generate_cuts(original_lp_, settings_, Arow_, new_slacks_, var_types_, basis_update, root_relax_soln_.x, basic_list, nonbasic_list); + f_t cut_generation_time = toc(cut_start_time); + if (cut_generation_time > 1.0) { + settings_.log.printf("Cut generation time %.2f seconds\n", cut_generation_time); + } + // Score the cuts + cut_pool.score_cuts(root_relax_soln_.x); + // Get the best cuts from the cut pool + csr_matrix_t cuts_to_add(0, original_lp_.num_cols, 0); + std::vector cut_rhs; + std::vector cut_types; + i_t num_cuts = cut_pool.get_best_cuts(cuts_to_add, cut_rhs, cut_types); + if (num_cuts == 0) + { + //settings_.log.printf("No cuts found\n"); + break; + } + for (i_t k = 0; k < cut_types.size(); k++) { + if (cut_types[k] == cut_type_t::MIXED_INTEGER_GOMORY) { + cut_info.num_gomory_cuts++; + } else if (cut_types[k] == cut_type_t::MIXED_INTEGER_ROUNDING) { + cut_info.num_mir_cuts++; + } else if (cut_types[k] == cut_type_t::KNAPSACK) { + cut_info.num_knapsack_cuts++; + } else if (cut_types[k] == cut_type_t::CHVATAL_GOMORY) { + cut_info.num_cg_cuts++; + } + } +#ifdef PRINT_CUT_INFO + cut_pool.print_cutpool_types(); + print_cut_types("In LP ", cut_types, settings_); + printf("Cut pool size: %d\n", cut_pool.pool_size()); +#endif + +#ifdef CHECK_CUT_MATRIX + if (cuts_to_add.check_matrix() != 0) { + settings_.log.printf("Bad cuts matrix\n"); + for (i_t i = 0; i < static_cast(cut_types.size()); ++i) + { + settings_.log.printf("row %d cut type %d\n", i, cut_types[i]); + } + return mip_status_t::NUMERICAL; + } +#endif + // Check against saved solution +#if 1 + if (saved_solution.size() > 0) { + csc_matrix_t cuts_to_add_col(cuts_to_add.m, cuts_to_add.n, cuts_to_add.row_start[cuts_to_add.m]); + cuts_to_add.to_compressed_col(cuts_to_add_col); + std::vector Cx(cuts_to_add.m); + matrix_vector_multiply(cuts_to_add_col, 1.0, saved_solution, 0.0, Cx); + for (i_t k = 0; k < num_cuts; k++) { + //printf("Cx[%d] = %e cut_rhs[%d] = %e\n", k, Cx[k], k, cut_rhs[k]); + if (Cx[k] > cut_rhs[k] + 1e-6) { + printf("Cut %d is violated by saved solution. Cx %e cut_rhs %e Diff: %e\n", k, Cx[k], cut_rhs[k], Cx[k] - cut_rhs[k]); + } + } + } +#endif + cut_pool_size = cut_pool.pool_size(); + + // Resolve the LP with the new cuts + settings_.log.debug("Solving LP with %d cuts (%d cut nonzeros). Cuts in pool %d. Total constraints %d\n", + num_cuts, + cuts_to_add.row_start[cuts_to_add.m], + cut_pool.pool_size(), + cuts_to_add.m + original_lp_.num_rows); + lp_settings.log.log = false; + + mutex_original_lp_.lock(); + i_t add_cuts_status = add_cuts(settings_, + cuts_to_add, + cut_rhs, + original_lp_, + new_slacks_, + root_relax_soln_, + basis_update, + basic_list, + nonbasic_list, + root_vstatus_, + edge_norms_); + mutex_original_lp_.unlock(); + if (add_cuts_status != 0) { + settings_.log.printf("Failed to add cuts\n"); + return mip_status_t::NUMERICAL; + } + + // Try to do bound strengthening + var_types_.resize(original_lp_.num_cols, variable_type_t::CONTINUOUS); + + std::vector bounds_changed(original_lp_.num_cols, true); + std::vector row_sense; +#ifdef CHECK_MATRICES + settings_.log.printf("Before A check\n"); + original_lp_.A.check_matrix(); +#endif + original_lp_.A.to_compressed_row(Arow_); + + bounds_strengthening_t node_presolve(original_lp_, Arow_, row_sense, var_types_); + bool feasible = node_presolve.bounds_strengthening(original_lp_.lower, original_lp_.upper, settings_); + + if (!feasible) { + settings_.log.printf("Bound strengthening failed\n"); + return mip_status_t::NUMERICAL; + } + + // Adjust the solution + root_relax_soln_.x.resize(original_lp_.num_cols, 0.0); + root_relax_soln_.y.resize(original_lp_.num_rows, 0.0); + root_relax_soln_.z.resize(original_lp_.num_cols, 0.0); + + // For now just clear the edge norms + edge_norms_.clear(); + i_t iter = 0; + bool initialize_basis = false; + lp_settings.concurrent_halt = NULL; + dual::status_t cut_status = dual_phase2_with_advanced_basis(2, + 0, + initialize_basis, + exploration_stats_.start_time, + original_lp_, + lp_settings, + root_vstatus_, + basis_update, + basic_list, + nonbasic_list, + root_relax_soln_, + iter, + edge_norms_); + if (cut_status == dual::status_t::TIME_LIMIT) { + solver_status_ = mip_status_t::TIME_LIMIT; + set_final_solution(solution, root_objective_); + return solver_status_; + } + + if (cut_status != dual::status_t::OPTIMAL) { + settings_.log.printf("Cut status %s\n", dual::status_to_string(cut_status).c_str()); + return mip_status_t::NUMERICAL; + } + exploration_stats_.total_lp_iters += root_relax_soln_.iterations; + root_objective_ = compute_objective(original_lp_, root_relax_soln_.x); + + local_lower_bounds_.assign(settings_.num_bfs_workers, root_objective_); + + mutex_original_lp_.lock(); + remove_cuts(original_lp_, + settings_, + Arow_, + new_slacks_, + original_rows, + var_types_, + root_vstatus_, + root_relax_soln_.x, + root_relax_soln_.y, + root_relax_soln_.z, + basic_list, + nonbasic_list, + basis_update); + mutex_original_lp_.unlock(); + + fractional.clear(); + num_fractional = fractional_variables(settings_, root_relax_soln_.x, var_types_, fractional); + + if (num_fractional == 0) { + upper_bound_ = root_objective_; + mutex_upper_.lock(); + incumbent_.set_incumbent_solution(root_objective_, root_relax_soln_.x); + mutex_upper_.unlock(); + } + f_t obj = upper_bound_.load(); + f_t user_obj = compute_user_objective(original_lp_, obj); + f_t user_lower = compute_user_objective(original_lp_, root_objective_); + std::string gap = num_fractional != 0 ? user_mip_gap(user_obj, user_lower) : "0.0%"; + + + settings_.log.printf(" %10d %10lu %+13.6e %+10.6e %6d %6d %7.1e %s %9.2f\n", + 0, + 0, + user_obj, + user_lower, + num_fractional, + 0, + static_cast(iter), + gap.c_str(), + toc(exploration_stats_.start_time)); + + f_t rel_gap = user_relative_gap(original_lp_, upper_bound_.load(), root_objective_); + f_t abs_gap = upper_bound_.load() - root_objective_; + if (rel_gap < settings_.relative_mip_gap_tol || abs_gap < settings_.absolute_mip_gap_tol) { + set_final_solution(solution, root_objective_); + return mip_status_t::OPTIMAL; + } } - if (settings_.heuristic_preemption_callback != nullptr) { - settings_.heuristic_preemption_callback(); + } + + print_cut_info(settings_, cut_info); + + if (cut_info.has_cuts()) { + settings_.log.printf("Cut pool size : %d\n", cut_pool_size); + settings_.log.printf("Size with cuts: %d constraints, %d variables, %d nonzeros\n", original_lp_.num_rows, original_lp_.num_cols, original_lp_.A.col_start[original_lp_.A.n]); + } + + if (edge_norms_.size() != original_lp_.num_cols) + { + edge_norms_.resize(original_lp_.num_cols, -1.0); + } + for (i_t k = 0; k < original_lp_.num_rows; k++) + { + const i_t j = basic_list[k]; + if (edge_norms_[j] < 0.0) + { + edge_norms_[j] = 1e-4; } - return mip_status_t::OPTIMAL; } pc_.resize(original_lp_.num_cols); @@ -1536,6 +2071,7 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut search_tree_.branch(&search_tree_.root, branch_var, root_relax_soln_.x[branch_var], + num_fractional, root_vstatus_, original_lp_, log); @@ -1550,14 +2086,12 @@ mip_status_t branch_and_bound_t::solve(mip_solution_t& solut exploration_stats_.nodes_since_last_log = 0; exploration_stats_.last_log = tic(); active_subtrees_ = 0; - is_running = true; lower_bound_ceiling_ = inf; should_report_ = true; settings_.log.printf( - " | Explored | Unexplored | Objective | Bound | Depth | Iter/Node | Gap " - "| Time |\n"); - + " | Explored | Unexplored | Objective | Bound | IntInf | Depth | Iter/Node | Gap " + "| Time |\n"); #pragma omp parallel num_threads(settings_.num_threads) { #pragma omp master diff --git a/cpp/src/dual_simplex/branch_and_bound.hpp b/cpp/src/dual_simplex/branch_and_bound.hpp index dac1ab393..1a947b2a2 100644 --- a/cpp/src/dual_simplex/branch_and_bound.hpp +++ b/cpp/src/dual_simplex/branch_and_bound.hpp @@ -8,6 +8,7 @@ #pragma once #include +#include #include #include #include @@ -71,7 +72,8 @@ template class branch_and_bound_t { public: branch_and_bound_t(const user_problem_t& user_problem, - const simplex_solver_settings_t& solver_settings); + const simplex_solver_settings_t& solver_settings, + f_t start_time); // Set an initial guess based on the user_problem. This should be called before solve. void set_initial_guess(const std::vector& user_guess) { guess_ = user_guess; } @@ -109,7 +111,15 @@ class branch_and_bound_t { bool enable_concurrent_lp_root_solve() const { return enable_concurrent_lp_root_solve_; } std::atomic* get_root_concurrent_halt() { return &root_concurrent_halt_; } void set_root_concurrent_halt(int value) { root_concurrent_halt_ = value; } - lp_status_t solve_root_relaxation(simplex_solver_settings_t const& lp_settings); + lp_status_t solve_root_relaxation(simplex_solver_settings_t const& lp_settings, + lp_solution_t& root_relax_soln, + std::vector& root_vstatus, + basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& edge_norms); + + void find_reduced_cost_fixings(f_t upper_bound); // The main entry routine. Returns the solver status and populates solution with the incumbent. mip_status_t solve(mip_solution_t& solution); @@ -126,6 +136,7 @@ class branch_and_bound_t { lp_problem_t original_lp_; std::vector new_slacks_; std::vector var_types_; + i_t num_integer_variables_; // Variable locks (see definition 3.3 from T. Achterberg, “Constraint Integer Programming,” // PhD, Technischen Universität Berlin, Berlin, 2007. doi: 10.14279/depositonce-1634). @@ -136,6 +147,9 @@ class branch_and_bound_t { // Local lower bounds for each thread std::vector> local_lower_bounds_; + // Mutex for the original LP + omp_mutex_t mutex_original_lp_; + // Mutex for upper bound omp_mutex_t mutex_upper_; @@ -186,7 +200,10 @@ class branch_and_bound_t { omp_atomic_t lower_bound_ceiling_; void report_heuristic(f_t obj); - void report(char symbol, f_t obj, f_t lower_bound, i_t node_depth); + void report(char symbol, f_t obj, f_t lower_bound, i_t node_depth, i_t node_int_infeas); + + // Set the solution when found at the root node + void set_solution_at_root(mip_solution_t& solution, const cut_info_t& cut_info); // Set the final solution. void set_final_solution(mip_solution_t& solution, f_t lower_bound); @@ -240,6 +257,7 @@ class branch_and_bound_t { dual::status_t solve_node_lp(mip_node_t* node_ptr, lp_problem_t& leaf_problem, lp_solution_t& leaf_solution, + std::vector& leaf_edge_norms, basis_update_mpf_t& basis_factors, std::vector& basic_list, std::vector& nonbasic_list, @@ -258,6 +276,7 @@ class branch_and_bound_t { search_tree_t& search_tree, lp_problem_t& leaf_problem, lp_solution_t& leaf_solution, + std::vector& leaf_edge_norms, bnb_worker_type_t thread_type, dual::status_t lp_status, logger_t& log); diff --git a/cpp/src/dual_simplex/crossover.cpp b/cpp/src/dual_simplex/crossover.cpp index 8ee3fb0ce..4115db3ba 100644 --- a/cpp/src/dual_simplex/crossover.cpp +++ b/cpp/src/dual_simplex/crossover.cpp @@ -1378,18 +1378,22 @@ crossover_status_t crossover(const lp_problem_t& lp, settings.log.debug("Num flips %d\n", num_flips); solution = phase1_solution; print_crossover_info(lp, settings, vstatus, solution, "Dual phase 1 complete"); - std::vector edge_norms; - dual::status_t status = dual_phase2( - 2, iter == 0 ? 1 : 0, start_time, lp, settings, vstatus, solution, iter, edge_norms); - if (toc(start_time) > settings.time_limit) { - settings.log.printf("Time limit exceeded\n"); - return crossover_status_t::TIME_LIMIT; - } - if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { - settings.log.printf("Concurrent halt\n"); - return crossover_status_t::CONCURRENT_LIMIT; + dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); + dual::status_t status = dual::status_t::NUMERICAL; + if (dual_infeas <= settings.dual_tol) { + std::vector edge_norms; + status = dual_phase2( + 2, iter == 0 ? 1 : 0, start_time, lp, settings, vstatus, solution, iter, edge_norms); + if (toc(start_time) > settings.time_limit) { + settings.log.printf("Time limit exceeded\n"); + return crossover_status_t::TIME_LIMIT; + } + if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { + settings.log.printf("Concurrent halt\n"); + return crossover_status_t::CONCURRENT_LIMIT; + } + solution.iterations += iter; } - solution.iterations += iter; primal_infeas = primal_infeasibility(lp, settings, vstatus, solution.x); dual_infeas = dual_infeasibility(lp, settings, vstatus, solution.z); primal_res = primal_residual(lp, solution); diff --git a/cpp/src/dual_simplex/cuts.cpp b/cpp/src/dual_simplex/cuts.cpp new file mode 100644 index 000000000..a75644ec0 --- /dev/null +++ b/cpp/src/dual_simplex/cuts.cpp @@ -0,0 +1,2925 @@ +/* clang-format off */ +/* + * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +/* clang-format on */ + +#include +#include +#include +#include + + +namespace cuopt::linear_programming::dual_simplex { + +template +void cut_pool_t::add_cut(cut_type_t cut_type, + const sparse_vector_t& cut, + f_t rhs) +{ + // TODO: Need to deduplicate cuts and only add if the cut is not already in the pool + + for (i_t p = 0; p < cut.i.size(); p++) { + const i_t j = cut.i[p]; + if (j >= original_vars_) { + settings_.log.printf( + "Cut has variable %d that is greater than original_vars_ %d\n", j, original_vars_); + return; + } + } + + sparse_vector_t cut_squeezed; + cut.squeeze(cut_squeezed); + if (cut_squeezed.i.size() == 0) { + settings_.log.printf("Cut has no coefficients\n"); + return; + } + cut_storage_.append_row(cut_squeezed); +#ifdef PRINT_ADD_CUTS + settings_.log.printf("Added cut %d to pool\n", cut_storage_.m - 1); +#endif + rhs_storage_.push_back(rhs); + cut_type_.push_back(cut_type); + cut_age_.push_back(0); +} + +template +f_t cut_pool_t::cut_distance(i_t row, + const std::vector& x, + f_t& cut_violation, + f_t& cut_norm) +{ + const i_t row_start = cut_storage_.row_start[row]; + const i_t row_end = cut_storage_.row_start[row + 1]; + f_t cut_x = 0.0; + f_t dot = 0.0; + for (i_t p = row_start; p < row_end; p++) { + const i_t j = cut_storage_.j[p]; + const f_t cut_coeff = cut_storage_.x[p]; + cut_x += cut_coeff * x[j]; + dot += cut_coeff * cut_coeff; + } + cut_violation = rhs_storage_[row] - cut_x; + cut_norm = std::sqrt(dot); + const f_t distance = cut_violation / cut_norm; + return distance; +} + +template +f_t cut_pool_t::cut_density(i_t row) +{ + const i_t row_start = cut_storage_.row_start[row]; + const i_t row_end = cut_storage_.row_start[row + 1]; + const i_t cut_nz = row_end - row_start; + const i_t original_vars = original_vars_; + return static_cast(cut_nz) / original_vars; +} + +template +f_t cut_pool_t::cut_orthogonality(i_t i, i_t j) +{ + const i_t i_start = cut_storage_.row_start[i]; + const i_t i_end = cut_storage_.row_start[i + 1]; + const i_t i_nz = i_end - i_start; + const i_t j_start = cut_storage_.row_start[j]; + const i_t j_end = cut_storage_.row_start[j + 1]; + const i_t j_nz = j_end - j_start; + + f_t dot = sparse_dot(cut_storage_.j.data() + i_start, + cut_storage_.x.data() + i_start, + i_nz, + cut_storage_.j.data() + j_start, + cut_storage_.x.data() + j_start, + j_nz); + + f_t norm_i = cut_norms_[i]; + f_t norm_j = cut_norms_[j]; + return 1.0 - std::abs(dot) / (norm_i * norm_j); +} + +template +void cut_pool_t::score_cuts(std::vector& x_relax) +{ + const f_t weight_distance = 1.0; + const f_t weight_orthogonality = 1.0; + const f_t min_cut_distance = 1e-4; + cut_distances_.resize(cut_storage_.m, 0.0); + cut_norms_.resize(cut_storage_.m, 0.0); + cut_orthogonality_.resize(cut_storage_.m, 1); + cut_scores_.resize(cut_storage_.m, 0.0); + const bool verbose = false; + for (i_t i = 0; i < cut_storage_.m; i++) { + f_t violation; + cut_distances_[i] = cut_distance(i, x_relax, violation, cut_norms_[i]); + cut_scores_[i] = + cut_distances_[i] <= min_cut_distance + ? 0.0 + : weight_distance * cut_distances_[i] + weight_orthogonality * cut_orthogonality_[i]; + if (verbose) { + settings_.log.printf( + "Cut %d type %d distance %+e violation %+e orthogonality %e score %.16e\n", + i, + static_cast(cut_type_[i]), + cut_distances_[i], + violation, + cut_orthogonality_[i], + cut_scores_[i]); + } + } + + std::vector sorted_indices(cut_storage_.m); + std::iota(sorted_indices.begin(), sorted_indices.end(), 0); + std::sort(sorted_indices.begin(), sorted_indices.end(), [&](i_t a, i_t b) { + return cut_scores_[a] > cut_scores_[b] || (cut_scores_[a] == cut_scores_[b] && cut_type_[a] > cut_type_[b]); + }); + + std::vector indices; + indices.reserve(sorted_indices.size()); + + + const i_t max_cuts = 2000; + const f_t min_orthogonality = 0.5; + best_cuts_.reserve(std::min(max_cuts, cut_storage_.m)); + best_cuts_.clear(); + scored_cuts_ = 0; + + while (scored_cuts_ < max_cuts && !sorted_indices.empty()) { + const i_t i = sorted_indices[0]; + + if (cut_distances_[i] <= min_cut_distance) { + //settings_.log.printf("Cut %d distance %e <= %e. Stopping\n", i, cut_distances_[i], min_cut_distance); + break; + } + + if (cut_age_[i] > 0) { + settings_.log.printf("Adding cut with age %d\n", cut_age_[i]); + } + if (verbose) { + settings_.log.printf("Scored cuts %d. Adding cut %d score %e\n", scored_cuts_, i, cut_scores_[i]); + } + + best_cuts_.push_back(i); + scored_cuts_++; + + // Recompute the orthogonality for the remaining cuts + for (i_t k = 1; k < sorted_indices.size(); k++) { + const i_t j = sorted_indices[k]; + cut_orthogonality_[j] = std::min(cut_orthogonality_[j], cut_orthogonality(i, j)); + if (cut_orthogonality_[j] >= min_orthogonality) { + indices.push_back(j); + if (cut_distances_[j] <= min_cut_distance) { + cut_scores_[j] = 0.0; // Ignore cuts under the minimum distance threshold + } else { + cut_scores_[j] = weight_distance * cut_distances_[j] + weight_orthogonality * cut_orthogonality_[j]; + } + } + } + + sorted_indices = indices; + indices.clear(); + + std::sort(sorted_indices.begin(), sorted_indices.end(), [&](i_t a, i_t b) { + return cut_scores_[a] > cut_scores_[b]; + }); + } +} + +template +i_t cut_pool_t::get_best_cuts(csr_matrix_t& best_cuts, + std::vector& best_rhs, + std::vector& best_cut_types) +{ + best_cuts.m = 0; + best_cuts.n = original_vars_; + best_cuts.row_start.clear(); + best_cuts.j.clear(); + best_cuts.x.clear(); + best_cuts.row_start.reserve(scored_cuts_ + 1); + best_cuts.row_start.push_back(0); + best_rhs.clear(); + best_rhs.reserve(scored_cuts_); + best_cut_types.clear(); + best_cut_types.reserve(scored_cuts_); + + for (i_t i: best_cuts_) { + sparse_vector_t cut(cut_storage_, i); + cut.negate(); + best_cuts.append_row(cut); + best_rhs.push_back(-rhs_storage_[i]); + best_cut_types.push_back(cut_type_[i]); + } + + age_cuts(); + + return static_cast(best_cuts_.size()); +} + +template +void cut_pool_t::age_cuts() +{ + for (i_t i = 0; i < cut_age_.size(); i++) { + cut_age_[i]++; + } +} + +template +void cut_pool_t::drop_cuts() +{ + // TODO: Implement this +} + +template +knapsack_generation_t::knapsack_generation_t( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types) +{ + const bool verbose = false; + knapsack_constraints_.reserve(lp.num_rows); + + is_slack_.resize(lp.num_cols, 0); + for (i_t j : new_slacks) { + is_slack_[j] = 1; + } + + for (i_t i = 0; i < lp.num_rows; i++) { + const i_t row_start = Arow.row_start[i]; + const i_t row_end = Arow.row_start[i + 1]; + const i_t row_len = row_end - row_start; + if (row_len < 3) { continue; } + bool is_knapsack = true; + f_t sum_pos = 0.0; + for (i_t p = row_start; p < row_end; p++) { + const i_t j = Arow.j[p]; + if (is_slack_[j]) { continue; } + const f_t aj = Arow.x[p]; + if (std::abs(aj - std::round(aj)) > settings.integer_tol) { + is_knapsack = false; + break; + } + if (var_types[j] != variable_type_t::INTEGER || lp.lower[j] != 0.0 || lp.upper[j] != 1.0) { + is_knapsack = false; + break; + } + if (aj < 0.0) { + is_knapsack = false; + break; + } + sum_pos += aj; + } + + if (is_knapsack) { + const f_t beta = lp.rhs[i]; + if (std::abs(beta - std::round(beta)) <= settings.integer_tol) { + if (beta > 0.0 && beta <= sum_pos && std::abs(sum_pos / (row_len - 1) - beta) > 1e-3) { + if (verbose) { + printf( + "Knapsack constraint %d row len %d beta %e sum_pos %e sum_pos / (row_len - 1) %e\n", + i, + row_len, + beta, + sum_pos, + sum_pos / (row_len - 1)); + } + knapsack_constraints_.push_back(i); + } + } + } + } + + i_t num_knapsack_constraints = knapsack_constraints_.size(); + settings.log.printf("Number of knapsack constraints %d\n", num_knapsack_constraints); +} + +template +i_t knapsack_generation_t::generate_knapsack_cuts( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar, + i_t knapsack_row, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + const bool verbose = false; + // Get the row associated with the knapsack constraint + sparse_vector_t knapsack_inequality(Arow, knapsack_row); + f_t knapsack_rhs = lp.rhs[knapsack_row]; + + // Remove the slacks from the inequality + f_t seperation_rhs = 0.0; + if (verbose) { + settings.log.printf(" Knapsack : "); + } + for (i_t k = 0; k < knapsack_inequality.i.size(); k++) { + const i_t j = knapsack_inequality.i[k]; + if (is_slack_[j]) { + knapsack_inequality.x[k] = 0.0; + } else { + if (verbose) { + settings.log.printf(" %g x%d +", knapsack_inequality.x[k], j); + } + seperation_rhs += knapsack_inequality.x[k]; + } + } + if (verbose) { + settings.log.printf(" <= %g\n", knapsack_rhs); + } + seperation_rhs -= (knapsack_rhs + 1); + + if (verbose) { + settings.log.printf("\t"); + for (i_t k = 0; k < knapsack_inequality.i.size(); k++) { + const i_t j = knapsack_inequality.i[k]; + if (!is_slack_[j]) { + if (std::abs(xstar[j]) > 1e-3) { settings.log.printf("x_relax[%d]= %g ", j, xstar[j]); } + } + } + settings.log.printf("\n"); + + settings.log.printf("seperation_rhs %g\n", seperation_rhs); + } + if (seperation_rhs <= 0.0) { return -1; } + + std::vector values; + values.resize(knapsack_inequality.i.size() - 1); + std::vector weights; + weights.resize(knapsack_inequality.i.size() - 1); + i_t h = 0; + f_t objective_constant = 0.0; + for (i_t k = 0; k < knapsack_inequality.i.size(); k++) { + const i_t j = knapsack_inequality.i[k]; + if (!is_slack_[j]) { + const f_t vj = std::min(1.0, std::max(0.0,1.0 - xstar[j])); + objective_constant += vj; + values[h] = vj; + weights[h] = knapsack_inequality.x[k]; + h++; + } + } + std::vector solution; + solution.resize(knapsack_inequality.i.size() - 1); + + if (verbose) { + settings.log.printf("Calling solve_knapsack_problem\n"); + } + f_t objective = solve_knapsack_problem(values, weights, seperation_rhs, solution); + if (objective != objective) { return -1; } + if (verbose) { + settings.log.printf("objective %e objective_constant %e\n", objective, objective_constant); + } + f_t seperation_value = -objective + objective_constant; + if (verbose) { + settings.log.printf("seperation_value %e\n", seperation_value); + } + const f_t tol = 1e-6; + if (seperation_value >= 1.0 - tol) { return -1; } + + i_t cover_size = 0; + for (i_t k = 0; k < solution.size(); k++) { + if (solution[k] == 0.0) { cover_size++; } + } + + cut.i.clear(); + cut.x.clear(); + cut.i.reserve(cover_size); + cut.x.reserve(cover_size); + + h = 0; + for (i_t k = 0; k < knapsack_inequality.i.size(); k++) { + const i_t j = knapsack_inequality.i[k]; + if (!is_slack_[j]) { + if (solution[h] == 0.0) { + //printf("x%d in cover. relaxation %e\n", j, xstar[j]); + cut.i.push_back(j); + cut.x.push_back(-1.0); + } + h++; + } + } + cut_rhs = -cover_size + 1; + cut.sort(); + + // The cut is in the form: - sum_{j in cover} x_j >= -cover_size + 1 + // Which is equivalent to: sum_{j in cover} x_j <= cover_size - 1 + + // Verify the cut is violated + f_t dot = cut.dot(xstar); + f_t violation = dot - cut_rhs; + if (verbose) { + settings.log.printf("Knapsack cut %d violation %e < 0\n", knapsack_row, violation); + } + + if (violation >= -tol) { return -1; } + +#ifdef PRINT_KNAPSACK_CUT + printf("knapsack cut (cover %d): \n", cover_size); + for (i_t k = 0; k < cut.i.size(); k++) { + printf("x%d coeff %g value %g\n", cut.i[k], -cut.x[k], xstar[cut.i[k]]); + } + printf("cut_rhs %g\n", -cut_rhs); +#endif + return 0; +} + +template +f_t knapsack_generation_t::greedy_knapsack_problem(const std::vector& values, + const std::vector& weights, + f_t rhs, + std::vector& solution) +{ + i_t n = weights.size(); + solution.assign(n, 0.0); + + // Build permutation + std::vector perm(n); + std::iota(perm.begin(), perm.end(), 0); + + std::vector ratios; + ratios.resize(n); + for (i_t i = 0; i < n; i++) { + ratios[i] = values[i] / weights[i]; + } + + // Sort by value / weight ratio + std::sort(perm.begin(), perm.end(), [&](i_t i, i_t j) { return ratios[i] > ratios[j]; }); + + // Greedy select items with the best value / weight ratio until the remaining capacity is exhausted + f_t remaining = rhs; + f_t total_value = 0.0; + + for (i_t j : perm) { + if (weights[j] <= remaining) { + solution[j] = 1.0; + remaining -= weights[j]; + total_value += values[j]; + } + } + + // Best single-item fallback + f_t best_single_value = 0.0; + i_t best_single_idx = -1; + + for (i_t j = 0; j < n; ++j) { + if (weights[j] <= rhs && values[j] > best_single_value) { + best_single_value = values[j]; + best_single_idx = j; + } + } + + if (best_single_value > total_value) { + solution.assign(n, 0.0); + solution[best_single_idx] = 1.0; + return best_single_value; + } + + return total_value; +} + +template +f_t knapsack_generation_t::solve_knapsack_problem(const std::vector& values, + const std::vector& weights, + f_t rhs, + std::vector& solution) +{ + // Solve the knapsack problem + // maximize sum_{j=0}^n values[j] * solution[j] + // subject to sum_{j=0}^n weights[j] * solution[j] <= rhs + // values: values of the items + // weights: weights of the items + // return the value of the solution + + // Using approximate dynamic programming + + i_t n = weights.size(); + f_t objective = std::numeric_limits::quiet_NaN(); + + // Compute the maximum value + f_t vmax = *std::max_element(values.begin(), values.end()); + + // Check if all the values are integers + bool all_integers = true; + const f_t integer_tol = 1e-5; + for (i_t j = 0; j < n; j++) { + if (std::abs(values[j] - std::round(values[j])) > integer_tol) { + all_integers = false; + break; + } + } + + const bool verbose = false; + + if (verbose) { + printf("all_integers %d\n", all_integers); + } + + // Compute the scaling factor and comptue the scaled integer values + f_t scale = 1.0; + std::vector scaled_values(n); + if (all_integers) { + for (i_t j = 0; j < n; j++) { + scaled_values[j] = static_cast(std::floor(values[j])); + } + } else { + const f_t epsilon = 0.1; + scale = epsilon * vmax / static_cast(n); + if (scale <= 0.0) { return std::numeric_limits::quiet_NaN(); } + if (verbose) { + printf("scale %g epsilon %g vmax %g n %d\n", scale, epsilon, vmax, n); + } + for (i_t i = 0; i < n; ++i) { + scaled_values[i] = static_cast(std::floor(values[i] / scale)); + } + } + + i_t sum_value = std::accumulate(scaled_values.begin(), scaled_values.end(), 0); + const i_t INT_INF = std::numeric_limits::max() / 2; + if (verbose) { + printf("sum value %d\n", sum_value); + } + const i_t max_size = 10000; + if (sum_value <= 0.0 || sum_value >= max_size) { + if (verbose) { + printf("sum value %d is negative or too large using greedy solution\n", sum_value); + } + return greedy_knapsack_problem(values, weights, rhs, solution); + } + + // dp(j, v) = minimum weight using first j items to get value v + dense_matrix_t dp(n + 1, sum_value + 1, INT_INF); + dense_matrix_t take(n + 1, sum_value + 1, 0); + dp(0, 0) = 0; + + // 4. Dynamic programming + for (i_t j = 1; j <= n; ++j) { + for (i_t v = 0; v <= sum_value; ++v) { + // Do not take item i-1 + dp(j, v) = dp(j - 1, v); + + // Take item j-1 if possible + if (v >= scaled_values[j - 1]) { + i_t candidate = dp(j - 1, v - scaled_values[j - 1]) + static_cast(std::floor(weights[j - 1])); + if (candidate < dp(j, v)) { + dp(j, v) = candidate; + take(j, v) = 1; + } + } + } + } + + // 5. Find best achievable value within capacity + i_t best_value = 0; + for (i_t v = 0; v <= sum_value; ++v) { + if (dp(n, v) <= rhs) { best_value = v; } + } + + // 6. Backtrack to recover solution + i_t v = best_value; + for (i_t j = n; j >= 1; --j) { + if (take(j, v)) { + solution[j - 1] = 1.0; + v -= scaled_values[j - 1]; + } else { + solution[j - 1] = 0.0; + } + } + + objective = best_value * scale; + return objective; +} + +template +void cut_generation_t::generate_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list) +{ + // Generate Gomory and CG Cuts + if (settings.mixed_integer_gomory_cuts != 0 || settings.strong_chvatal_gomory_cuts != 0) { + f_t cut_start_time = tic(); + generate_gomory_cuts( + lp, settings, Arow, new_slacks, var_types, basis_update, xstar, basic_list, nonbasic_list); + f_t cut_generation_time = toc(cut_start_time); + if (cut_generation_time > 1.0) { + settings.log.printf("Gomory and CG cut generation time %.2f seconds\n", cut_generation_time); + } + } + + // Generate Knapsack cuts + if (settings.knapsack_cuts != 0) { + f_t cut_start_time = tic(); + generate_knapsack_cuts(lp, settings, Arow, new_slacks, var_types, xstar); + f_t cut_generation_time = toc(cut_start_time); + if (cut_generation_time > 1.0) { + settings.log.printf("Knapsack cut generation time %.2f seconds\n", cut_generation_time); + } + } + + // Generate MIR and CG cuts + if (settings.mir_cuts != 0 || settings.strong_chvatal_gomory_cuts != 0) { + f_t cut_start_time = tic(); + generate_mir_cuts(lp, settings, Arow, new_slacks, var_types, xstar); + f_t cut_generation_time = toc(cut_start_time); + if (cut_generation_time > 1.0) { + settings.log.printf("MIR and CG cut generation time %.2f seconds\n", cut_generation_time); + } + } +} + +template +void cut_generation_t::generate_knapsack_cuts( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar) +{ + if (knapsack_generation_.num_knapsack_constraints() > 0) { + for (i_t knapsack_row : knapsack_generation_.get_knapsack_constraints()) { + sparse_vector_t cut(lp.num_cols, 0); + f_t cut_rhs; + i_t knapsack_status = knapsack_generation_.generate_knapsack_cuts( + lp, settings, Arow, new_slacks, var_types, xstar, knapsack_row, cut, cut_rhs); + if (knapsack_status == 0) { + cut_pool_.add_cut(cut_type_t::KNAPSACK, cut, cut_rhs); + } + } + } +} + +template +void cut_generation_t::generate_mir_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar) +{ + f_t mir_start_time = tic(); + mixed_integer_rounding_cut_t mir(lp, settings, new_slacks, xstar); + strong_cg_cut_t cg(lp, var_types, xstar); + + std::vector slack_map(lp.num_rows, -1); + for (i_t slack : new_slacks) { + const i_t col_start = lp.A.col_start[slack]; + const i_t col_end = lp.A.col_start[slack + 1]; + const i_t col_len = col_end - col_start; + assert(col_len == 1); + const i_t i = lp.A.i[col_start]; + slack_map[i] = slack; + } + + // Compute initial scores for all rows + std::vector score(lp.num_rows, 0.0); + for (i_t i = 0; i < lp.num_rows; i++) { + const i_t row_start = Arow.row_start[i]; + const i_t row_end = Arow.row_start[i + 1]; + + const i_t row_nz = row_end - row_start; + i_t num_integer_in_row = 0; + i_t num_continuous_in_row = 0; + for (i_t p = row_start; p < row_end; p++) + { + const i_t j = Arow.j[p]; + if (var_types[j] == variable_type_t::INTEGER) + { + num_integer_in_row++; + } else { + num_continuous_in_row++; + } + } + + if (num_integer_in_row == 0) + { + score[i] = 0.0; + + } else { + f_t nz_score = lp.num_cols - row_nz; + + const i_t slack = slack_map[i]; + const f_t slack_value = xstar[slack]; + + f_t slack_score = -std::log10(1e-16 + std::abs(slack_value)); + + const f_t nz_weight = 1.0; + const f_t slack_weight = 1.0; + + score[i] = nz_weight * nz_score + slack_weight * slack_score; + } + } + + // Sort the rows by score + std::vector sorted_indices(lp.num_rows); + std::iota(sorted_indices.begin(), sorted_indices.end(), 0); + std::sort(sorted_indices.begin(), sorted_indices.end(), [&](i_t a, i_t b) { + return score[a] > score[b]; + }); + + // These data structures are used to track the rows that have been aggregated + // The invariant is that aggregated_rows is empty and aggregated_mark is all zeros + // at the beginning of each iteration of the for loop below + std::vector aggregated_rows; + std::vector aggregated_mark(lp.num_rows, 0); + + const i_t max_cuts = std::min(lp.num_rows, 1000); + for (i_t h = 0; h < max_cuts; h++) { + // Get the row with the highest score + const i_t i = sorted_indices[0]; + const f_t max_score = score[i]; + + const i_t row_nz = Arow.row_start[i+1] - Arow.row_start[i]; + const i_t slack = slack_map[i]; + const f_t slack_value = xstar[slack]; + + //printf("MIR %d/%d. row %d nz %d slack %e score %e\n", h, max_cuts, i, row_nz, slack_value, max_score); + + if (max_score <= 0.0) { + break; + } + + sparse_vector_t inequality(Arow, i); + f_t inequality_rhs = lp.rhs[i]; + const bool generate_cg_cut = settings.strong_chvatal_gomory_cuts != 0; + f_t fractional_part_rhs = fractional_part(inequality_rhs); + if (generate_cg_cut && fractional_part_rhs > 1e-6 && fractional_part_rhs < (1-1e-6)) + { + // Try to generate a CG cut + //printf("Trying to generate a CG cut from row %d\n", i); + sparse_vector_t cg_inequality = inequality; + f_t cg_inequality_rhs = inequality_rhs; + if (fractional_part(inequality_rhs) < 0.5) { + // Multiply by -1 to force the fractional part to be greater than 0.5 + cg_inequality_rhs *= -1; + cg_inequality.negate(); + } + sparse_vector_t cg_cut(lp.num_cols, 0); + f_t cg_cut_rhs; + i_t cg_status = cg.generate_strong_cg_cut( + lp, settings, var_types, cg_inequality, cg_inequality_rhs, xstar, cg_cut, cg_cut_rhs); + if (cg_status == 0) { + //printf("Adding CG cut nz %ld status %d row %d rhs %e inequality nz %d\n", cg_cut.i.size(), cg_status, i, cg_inequality_rhs, cg_inequality.i.size()); + cut_pool_.add_cut(cut_type_t::CHVATAL_GOMORY, cg_cut, cg_cut_rhs); + } + } + + // Remove the slack from the equality to get an inequality + i_t negate_inequality = 1; + for (i_t k = 0; k < inequality.i.size(); k++) { + const i_t j = inequality.i[k]; + if (j == slack) { + if (inequality.x[k] != 1.0) { + if (inequality.x[k] == -1.0 && lp.lower[j] >= 0.0) { + negate_inequality = 0; + } else { + printf("Bad slack %d in inequality: aj %e lo %e up %e\n", j, inequality.x[k], lp.lower[j], lp.upper[j]); + negate_inequality = -1; + break; + } + } + inequality.x[k] = 0.0; + } + } + + if (negate_inequality == -1) { + break; // TODO: this stops us from generating further MIR cuts for other rows. + } + + if (negate_inequality) { + // inequaility'*x <= inequality_rhs + // But for MIR we need: inequality'*x >= inequality_rhs + inequality_rhs *= -1; + inequality.negate(); + } + // We should now have: inequality'*x >= inequality_rhs + + // Transform the relaxation solution + std::vector transformed_xstar; + mir.relaxation_to_nonnegative(lp, xstar, transformed_xstar); + + + sparse_vector_t cut(lp.num_cols, 0); + f_t cut_rhs; + bool add_cut = false; + i_t num_aggregated = 0; + const i_t max_aggregated = 6; + + while (!add_cut && num_aggregated < max_aggregated) { + //printf("\t add_cut %d num_aggregated %d nz %ld\n", static_cast(add_cut), num_aggregated, inequality.i.size()); + + sparse_vector_t transformed_inequality; + inequality.squeeze(transformed_inequality); + f_t transformed_rhs = inequality_rhs; + + mir.to_nonnegative(lp, transformed_inequality, transformed_rhs); + std::vector> transformed_cuts; + std::vector transformed_cut_rhs; + std::vector transformed_violations; + + // Generate cut for delta = 1 + { + sparse_vector_t cut_1(lp.num_cols, 0); + f_t cut_1_rhs; + mir.generate_cut_nonnegative(transformed_inequality, transformed_rhs, var_types, cut_1, cut_1_rhs); + f_t cut_1_violation = mir.compute_violation(cut_1, cut_1_rhs, transformed_xstar); + if (cut_1_violation > 1e-6) + { + //printf("Cut 1: Found violation of %e\n", cut_1_violation); + transformed_cuts.push_back(cut_1); + transformed_cut_rhs.push_back(cut_1_rhs); + transformed_violations.push_back(cut_1_violation); + } else { + //printf("Cut 1: No violation %e\n", cut_1_violation); + } + } + + // Generate a cut for delta = max { |a_j|, j in I} + { + f_t max_coeff = 0.0; + for (i_t k = 0; k < transformed_inequality.i.size(); k++) + { + const i_t j = transformed_inequality.i[k]; + if (var_types[j] == variable_type_t::INTEGER) + { + const f_t abs_aj = std::abs(transformed_inequality.x[k]); + if (abs_aj > max_coeff) + { + max_coeff = abs_aj; + } + } + } + //printf("Cut 2 max_coeff %e size %ld\n", max_coeff, transformed_inequality.i.size()); + + if (max_coeff > 1e-6 && max_coeff != 1.0) + { + + sparse_vector_t scaled_inequality = transformed_inequality; + const i_t nz = transformed_inequality.i.size(); + for (i_t k = 0; k < nz; k++) + { + scaled_inequality.x[k] /= max_coeff; + } + const f_t scaled_rhs = transformed_rhs / max_coeff; + sparse_vector_t cut_2(lp.num_cols, 0); + f_t cut_2_rhs; + mir.generate_cut_nonnegative(scaled_inequality, scaled_rhs, var_types, cut_2, cut_2_rhs); + f_t cut_2_violation = mir.compute_violation(cut_2, cut_2_rhs, transformed_xstar); + if (cut_2_violation > 1e-6) + { + //printf("Cut 2: Found violation of %e\n", cut_2_violation); + transformed_cuts.push_back(cut_2); + transformed_cut_rhs.push_back(cut_2_rhs); + transformed_violations.push_back(cut_2_violation); + } + else { + //printf("Cut 2: no violation %e\n", cut_2_violation); + } + + } + } + + if (!transformed_violations.empty()) { + std::vector permuted(transformed_violations.size()); + std::iota(permuted.begin(), permuted.end(), 0); + std::sort(permuted.begin(), permuted.end(), [&](i_t i, i_t j) { + return transformed_violations[i] > transformed_violations[j]; + }); + + // Get the biggest violation + const i_t best_index = permuted[0]; + //printf("\tBest index %d\n", best_index); + f_t max_viol = transformed_violations[best_index]; + cut = transformed_cuts[best_index]; + cut_rhs = transformed_cut_rhs[best_index]; + + if (max_viol > 1e-6) { + // TODO: Divide by 1/2*violation, 1/4*violation, 1/8*violation + // Transform back to the original variables + mir.to_original(lp, cut, cut_rhs); + mir.remove_small_coefficients(lp.lower, lp.upper, cut, cut_rhs); + mir.substitute_slacks(lp, Arow, cut, cut_rhs); + f_t viol = mir.compute_violation(cut, cut_rhs, xstar); + //printf("after slacks and small coeff. Violation %e\n", viol); + add_cut = true; + } + } + + if (add_cut) { + if (num_aggregated > 0) { + //settings.log.printf("MIR cut with aggregation %d\n", num_aggregated); + } + if (settings.mir_cuts != 0) { + cut_pool_.add_cut(cut_type_t::MIXED_INTEGER_ROUNDING, cut, cut_rhs); + } + break; + } else { + // Perform aggregation to try and find a cut + + // Find all the continuous variables in the inequality + i_t num_continuous = 0; + f_t max_off_bound = 0.0; + i_t max_off_bound_var = -1; + for (i_t p = 0; p < inequality.i.size(); p++) { + const i_t j = inequality.i[p]; + if (var_types[j] == variable_type_t::CONTINUOUS) { + num_continuous++; + + const f_t off_lower = lp.lower[j] > -inf ? xstar[j] - lp.lower[j] : std::abs(xstar[j]); + const f_t off_upper = lp.upper[j] < inf ? lp.upper[j] - xstar[j] : std::abs(xstar[j]); + const f_t off_bound = std::max(off_lower, off_upper); + const i_t col_start = lp.A.col_start[j]; + const i_t col_end = lp.A.col_start[j+1]; + const i_t col_len = col_end - col_start; + if (off_bound > max_off_bound && col_len > 1) { + max_off_bound = off_bound; + max_off_bound_var = j; + } + } + } + //printf("\tnum_continuous %d max_off_bound %e var %d\n", num_continuous, max_off_bound, max_off_bound_var); + + if (num_continuous == 0 || max_off_bound < 1e-6) { + break; + } + + // The variable that is farthest from its bound is used as a pivot + if (max_off_bound_var > 0) { + const i_t col_start = lp.A.col_start[max_off_bound_var]; + const i_t col_end = lp.A.col_start[max_off_bound_var + 1]; + const i_t col_len = col_end - col_start; + const i_t max_potential_rows = 10; + if (col_len > 1) { + std::vector potential_rows; + potential_rows.reserve(col_len); + + const f_t threshold = 1e-4; + for (i_t q = col_start; q < col_end; q++) { + const i_t i = lp.A.i[q]; + const f_t val = lp.A.x[q]; + // Can't use rows that have already been aggregated + if (std::abs(val) > threshold && aggregated_mark[i] == 0) { potential_rows.push_back(i); } + if (potential_rows.size() >= max_potential_rows) { break; } + } + + if (!potential_rows.empty()) { + std::sort(potential_rows.begin(), potential_rows.end(), [&](i_t a, i_t b) { + return score[a] > score[b]; + }); + + const i_t pivot_row = potential_rows[0]; + + sparse_vector_t pivot_row_inequality(Arow, pivot_row); + f_t pivot_row_rhs = lp.rhs[pivot_row]; + //printf("\tCombining with %d\n", pivot_row); + mir.combine_rows(lp, + Arow, + max_off_bound_var, + pivot_row_inequality, + pivot_row_rhs, + inequality, + inequality_rhs); + aggregated_rows.push_back(pivot_row); + aggregated_mark[pivot_row] = 1; + } else { + //printf("\tno potential rows to aggregate\n"); + break; + } + } else { + settings.log.printf("Bad col len\n"); + assert(col_len > 1); + } + } + num_aggregated++; // Always increase so the loop terminates + } + } + + if (add_cut) { + // We were successful in generating a cut. + + // Set the score of the aggregated rows to zero + for (i_t row : aggregated_rows) { + score[row] = 0.0; + } + + // Clear the aggregated mark + for (i_t row : aggregated_rows) { + aggregated_mark[row] = 0; + } + // Clear the aggregated rows + aggregated_rows.clear(); + } + + // Set the score of the current row to zero + score[i] = 0.0; + + // Re-sort the rows by score + // It's possible this could be made more efficient by storing the rows in a data structure + // that allows us to: + // 1. Get the row with the best score + // 2. Get the row with a nonzero in column j that has the best score + // 3. Remove the rows that have been aggregated + // 4. Remove the current row + std::iota(sorted_indices.begin(), sorted_indices.end(), 0); + std::sort(sorted_indices.begin(), sorted_indices.end(), [&](i_t a, i_t b) { + return score[a] > score[b]; + }); + } +} + + +template +void cut_generation_t::generate_gomory_cuts( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list) +{ + tableau_equality_t tableau(lp, basis_update, nonbasic_list); + mixed_integer_rounding_cut_t mir(lp, settings, new_slacks, xstar); + strong_cg_cut_t cg(lp, var_types, xstar); + + for (i_t i = 0; i < lp.num_rows; i++) { + sparse_vector_t inequality(lp.num_cols, 0); + f_t inequality_rhs; + const i_t j = basic_list[i]; + if (var_types[j] != variable_type_t::INTEGER) { continue; } + const f_t x_j = xstar[j]; + if (std::abs(x_j - std::round(x_j)) < settings.integer_tol) { continue; } + i_t tableau_status = tableau.generate_base_equality(lp, + settings, + Arow, + var_types, + basis_update, + xstar, + basic_list, + nonbasic_list, + i, + inequality, + inequality_rhs); + if (tableau_status == 0) { + // Generate a CG cut + const bool generate_cg_cut = settings.strong_chvatal_gomory_cuts != 0; + if (generate_cg_cut) + { + // Try to generate a CG cut + sparse_vector_t cg_inequality = inequality; + f_t cg_inequality_rhs = inequality_rhs; + if (fractional_part(inequality_rhs) < 0.5) { + // Multiply by -1 to force the fractional part to be greater than 0.5 + cg_inequality_rhs *= -1; + cg_inequality.negate(); + } + sparse_vector_t cg_cut(lp.num_cols, 0); + f_t cg_cut_rhs; + i_t cg_status = cg.generate_strong_cg_cut( + lp, settings, var_types, cg_inequality, cg_inequality_rhs, xstar, cg_cut, cg_cut_rhs); + if (cg_status == 0) { + //printf("Adding CG cut nz %ld\n", cg_cut.i.size()); + cut_pool_.add_cut(cut_type_t::CHVATAL_GOMORY, cg_cut, cg_cut_rhs); + } + } + + if (settings.mixed_integer_gomory_cuts == 0) { + continue; + } + + // Given the base inequality, generate a MIR cut + sparse_vector_t cut_A(lp.num_cols, 0); + f_t cut_A_rhs; + i_t mir_status = + mir.generate_cut(inequality, inequality_rhs, lp.upper, lp.lower, var_types, cut_A, cut_A_rhs); + bool A_valid = false; + f_t cut_A_distance = 0.0; + if (mir_status == 0) { + if (cut_A.i.size() == 0) { + settings.log.printf("No coefficients in cut A\n"); + continue; + } + mir.substitute_slacks(lp, Arow, cut_A, cut_A_rhs); + if (cut_A.i.size() == 0) { + settings.log.printf("No coefficients in cut A after substituting slacks\n"); + A_valid = false; + } else { + // Check that the cut is violated + f_t dot = cut_A.dot(xstar); + f_t cut_norm = cut_A.norm2_squared(); + if (dot >= cut_A_rhs) { + continue; + } + cut_A_distance = (cut_A_rhs - dot) / std::sqrt(cut_norm); + A_valid = true; + } + } + + // Negate the base inequality + inequality.negate(); + inequality_rhs *= -1; + + sparse_vector_t cut_B(lp.num_cols, 0); + f_t cut_B_rhs; + + mir_status = + mir.generate_cut(inequality, inequality_rhs, lp.upper, lp.lower, var_types, cut_B, cut_B_rhs); + bool B_valid = false; + f_t cut_B_distance = 0.0; + if (mir_status == 0) { + if (cut_B.i.size() == 0) { + settings.log.printf("No coefficients in cut B\n"); + continue; + } + mir.substitute_slacks(lp, Arow, cut_B, cut_B_rhs); + if (cut_B.i.size() == 0) { + settings.log.printf("No coefficients in cut B after substituting slacks\n"); + B_valid = false; + } else { + // Check that the cut is violated + f_t dot = cut_B.dot(xstar); + f_t cut_norm = cut_B.norm2_squared(); + if (dot >= cut_B_rhs) { + continue; + } + cut_B_distance = (cut_B_rhs - dot) / std::sqrt(cut_norm); + B_valid = true; + } + } + + if ((cut_A_distance > cut_B_distance) && A_valid) { + cut_pool_.add_cut(cut_type_t::MIXED_INTEGER_GOMORY, cut_A, cut_A_rhs); + } else if (B_valid) { + cut_pool_.add_cut(cut_type_t::MIXED_INTEGER_GOMORY, cut_B, cut_B_rhs); + } + } + } +} + +template +i_t tableau_equality_t::generate_base_equality( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list, + i_t i, + sparse_vector_t& inequality, + f_t& inequality_rhs) +{ + // Let's look for Gomory cuts + const i_t j = basic_list[i]; + if (var_types[j] != variable_type_t::INTEGER) { return -1; } + const f_t x_j = xstar[j]; + if (std::abs(x_j - std::round(x_j)) < settings.integer_tol) { return -1; } +#ifdef PRINT_CUT_INFO + settings_.log.printf("Generating cut for variable %d relaxed value %e row %d\n", j, x_j, i); +#endif +#ifdef PRINT_BASIS + for (i_t h = 0; h < basic_list.size(); h++) { + settings_.log.printf("basic_list[%d] = %d\n", h, basic_list[h]); + } +#endif + + // Solve B^T u_bar = e_i + sparse_vector_t e_i(lp.num_rows, 1); + e_i.i[0] = i; + e_i.x[0] = 1.0; + sparse_vector_t u_bar(lp.num_rows, 0); + basis_update.b_transpose_solve(e_i, u_bar); + + +#ifdef CHECK_B_TRANSPOSE_SOLVE + std::vector u_bar_dense(lp.num_rows); + u_bar.to_dense(u_bar_dense); + + std::vector BTu_bar(lp.num_rows); + b_transpose_multiply(lp, basic_list, u_bar_dense, BTu_bar); + for (i_t k = 0; k < lp.num_rows; k++) { + if (k == i) { + settings.log.printf("BTu_bar %d error %e\n", k, std::abs(BTu_bar[k] - 1.0)); + if (std::abs(BTu_bar[k] - 1.0) > 1e-10) { + settings.log.printf("BTu_bar[%d] = %e i %d\n", k, BTu_bar[k], i); + assert(false); + } + } else { + settings.log.printf("BTu_bar %d error %e\n", k, std::abs(BTu_bar[k])); + if (std::abs(BTu_bar[k]) > 1e-10) { + settings.log.printf("BTu_bar[%d] = %e i %d\n", k, BTu_bar[k], i); + assert(false); + } + } + } +#endif + + // Compute a_bar = N^T u_bar + // TODO: This is similar to a function in phase2 of dual simplex. See if it can be reused. + const i_t nz_ubar = u_bar.i.size(); + std::vector abar_indices; + abar_indices.reserve(nz_ubar); + for (i_t k = 0; k < nz_ubar; k++) { + const i_t ii = u_bar.i[k]; + const f_t u_bar_i = u_bar.x[k]; + const i_t row_start = Arow.row_start[ii]; + const i_t row_end = Arow.row_start[ii + 1]; + for (i_t p = row_start; p < row_end; p++) { + const i_t jj = Arow.j[p]; + if (nonbasic_mark_[jj] == 1) { + x_workspace_[jj] += u_bar_i * Arow.x[p]; + if (!x_mark_[jj]) { + x_mark_[jj] = 1; + abar_indices.push_back(jj); + } + } + } + } + // TODO: abar has lots of small coefficients. It would be good to drop them. + // But we need to be careful not to accidently create a base (in)equality + // that cuts off an integer solution. + + i_t small_coeff = 0; + const f_t drop_tol = 1e-12; + const bool drop_coefficients = true; + sparse_vector_t a_bar(lp.num_cols, 0) ; + a_bar.i.reserve(abar_indices.size() + 1); + a_bar.x.reserve(abar_indices.size() + 1); + for (i_t k = 0; k < abar_indices.size(); k++) { + const i_t jj = abar_indices[k]; + if (drop_coefficients && std::abs(x_workspace_[jj]) < drop_tol) { + small_coeff++; + } else { + a_bar.i.push_back(jj); + a_bar.x.push_back(x_workspace_[jj]); + } + } + const bool verbose = false; + if (verbose && small_coeff > 0) { + settings.log.printf("Small coeff dropped %d\n", small_coeff); + } + + // Clear the workspace + for (i_t jj : abar_indices) { + x_workspace_[jj] = 0.0; + x_mark_[jj] = 0; + } + abar_indices.clear(); + + // We should now have the base inequality + // x_j + a_bar^T x_N >= b_bar_i + // We add x_j into a_bar so that everything is in a single sparse_vector_t + a_bar.i.push_back(j); + a_bar.x.push_back(1.0); + +#ifdef CHECK_A_BAR_DENSE_DOT + std::vector a_bar_dense(lp.num_cols); + a_bar.to_dense(a_bar_dense); + + f_t a_bar_dense_dot = dot(a_bar_dense, xstar); + if (std::abs(a_bar_dense_dot - b_bar[i]) > 1e-6) { + settings_.log.printf("a_bar_dense_dot = %e b_bar[%d] = %e\n", a_bar_dense_dot, i, b_bar[i]); + settings_.log.printf("x_j %e b_bar_i %e\n", x_j, b_bar[i]); + assert(false); + } +#endif + + // We have that x_j + a_bar^T x_N == b_bar_i + // So x_j + a_bar^T x_N >= b_bar_i + // And x_j + a_bar^T x_N <= b_bar_i + // Or -x_j - a_bar^T x_N >= -b_bar_i + +#ifdef PRINT_CUT + { + settings_.log.printf("Cut %d\n", i); + for (i_t k = 0; k < a_bar.i.size(); k++) { + const i_t jj = a_bar.i[k]; + const f_t aj = a_bar.x[k]; + settings_.log.printf("(%d, %e) ", jj, aj); + } + settings_.log.printf("\nEnd cut %d b_bar[%d] = %e\n", i, b_bar[i]); + } +#endif + + // Skip cuts that are shallow + const f_t shallow_tol = 1e-2; + if (std::abs(x_j - std::round(x_j)) < shallow_tol) { + //settings_.log.printf("Skipping shallow cut %d. b_bar[%d] = %e x_j %e\n", i, i, b_bar[i], x_j); + return -1; + } + + const f_t f_val = b_bar_[i] - std::floor(b_bar_[i]); + if (f_val < 0.01 || f_val > 0.99) { + //settings_.log.printf("Skipping cut %d. b_bar[%d] = %e f_val %e\n", i, i, b_bar[i], f_val); + return -1; + } + +#ifdef PRINT_BASE_INEQUALITY + // Print out the base inequality + for (i_t k = 0; k < a_bar.i.size(); k++) { + const i_t jj = a_bar.i[k]; + const f_t aj = a_bar.x[k]; + settings_.log.printf("a_bar[%d] = %e\n", k, aj); + } + settings_.log.printf("b_bar[%d] = %e\n", i, b_bar[i]); +#endif + + inequality = a_bar; + inequality_rhs = b_bar_[i]; + + return 0; +} + +template +mixed_integer_rounding_cut_t::mixed_integer_rounding_cut_t( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& new_slacks, + const std::vector& xstar) + : num_vars_(lp.num_cols), + settings_(settings), + x_workspace_(num_vars_, 0.0), + x_mark_(num_vars_, 0), + has_lower_(num_vars_, 0), + has_upper_(num_vars_, 0), + is_slack_(num_vars_, 0), + slack_rows_(num_vars_, 0), + bound_info_(num_vars_, 0) +{ + for (i_t j : new_slacks) { + is_slack_[j] = 1; + const i_t col_start = lp.A.col_start[j]; + const i_t i = lp.A.i[col_start]; + slack_rows_[j] = i; + assert(std::abs(lp.A.x[col_start]) == 1.0); + } + + needs_complement_ = false; + for (i_t j = 0; j < num_vars_; j++) { + if (lp.lower[j] < 0) { + //settings_.log.printf("Variable %d has negative lower bound %e\n", j, lp.lower[j]); + } + const f_t uj = lp.upper[j]; + const f_t lj = lp.lower[j]; + const f_t xstar_j = xstar[j]; + if (uj < inf) { + if (uj - xstar_j <= xstar_j - lj) { + has_upper_[j] = 1; + bound_info_[j] = 1; + needs_complement_ = true; + } else if (lj != 0.0) { + has_lower_[j] = 1; + bound_info_[j] = -1; + needs_complement_ = true; + } + continue; + } + + if (lj > -inf && lj != 0.0) { + has_lower_[j] = 1; + bound_info_[j] = -1; + needs_complement_ = true; + } + } +} + +template +void mixed_integer_rounding_cut_t::to_nonnegative(const lp_problem_t& lp, + sparse_vector_t& inequality, + f_t& rhs) +{ + const i_t nz = inequality.i.size(); + for (i_t k = 0; k < nz; k++) + { + const i_t j = inequality.i[k]; + const f_t aj = inequality.x[k]; + if (bound_info_[j] == -1) + { + // v_j = x_j - l_j, v_j >= 0 + // x_j = v_j + l_j + // sum_{k != j} a_k x_j + a_j x_j <= beta + // sum_{k != j} a_k x_j + a_j (v_j + l_j) <= beta + // sum_{k != j} a_k x_j + a_j v_j <= beta - a_j l_j + const f_t lj = lp.lower[j]; + rhs -= aj * lj; + } + else if (bound_info_[j] == 1) + { + // w_j = u_j - x_j, w_j >= 0 + // x_j = u_j - w_j + // sum_{k != j} a_k x_k + a_j x_j <= beta + // sum_{k != j} a_k x_k + a_j (u_j - w_j) <= beta + // sum_{k != j} a_k x_k - a_j w_j <= beta - a_j u_j + const f_t uj = lp.upper[j]; + inequality.x[k] *= -1.0; + rhs -= aj * uj; + } + } +} + +template +void mixed_integer_rounding_cut_t::relaxation_to_nonnegative( + const lp_problem_t& lp, + const std::vector& xstar, + std::vector& xstar_nonnegative) +{ + xstar_nonnegative = xstar; + const i_t n = lp.num_cols; + for (i_t j = 0; j < n; ++j) + { + if (bound_info_[j] == -1) + { + // v_j = x_j - l_j + const f_t lj = lp.lower[j]; + xstar_nonnegative[j] -= lj; + } else if (bound_info_[j] == 1) + { + // w_j = u_j - x_j + const f_t uj = lp.upper[j]; + xstar_nonnegative[j] = uj - xstar_nonnegative[j]; + } + } +} + + +template +void mixed_integer_rounding_cut_t::to_original(const lp_problem_t& lp, + sparse_vector_t& inequality, + f_t& rhs) +{ + const i_t nz = inequality.i.size(); + for (i_t k = 0; k < nz; k++) + { + const i_t j = inequality.i[k]; + const f_t dj = inequality.x[k]; + if (bound_info_[j] == -1) + { + // v_j = x_j - l_j, v_j >= 0 + // sum_{k != j} d_k x_k + d_j v_j >= beta + // sum_{k != j} d_k x_k + d_j (x_j - l_j) >= beta + // sum_{k != j} d_k x_k + d_j x_j >= beta + d_j l_j + const f_t lj = lp.lower[j]; + rhs += dj * lj; + } else if (bound_info_[j] == 1) + { + // w_j = u_j - x_j, w_j >= 0 + // sum_{k != j} d_k x_k + d_j w_j >= beta + // sum_{k != j} d_k x_k + d_j (u_j - x_j) >= beta + // sum_{k != j} d_k x_k - d_j x_j >= beta - d_j u_j + const f_t uj = lp.upper[j]; + inequality.x[k] *= -1.0; + rhs -= dj * uj; + } + } +} + +template +void mixed_integer_rounding_cut_t::remove_small_coefficients( + const std::vector& lower_bounds, + const std::vector& upper_bounds, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + const i_t nz = cut.i.size(); + i_t removed = 0; + for (i_t k = 0; k < cut.i.size(); k++) { + const i_t j = cut.i[k]; + + // Check for small coefficients + const f_t aj = cut.x[k]; + if (std::abs(aj) < 1e-6) { + if (aj >= 0.0 && upper_bounds[j] < inf) { + // Move this to the right-hand side + cut_rhs -= aj * upper_bounds[j]; + cut.x[k] = 0.0; + removed++; + } else if (aj <= 0.0 && lower_bounds[j] > -inf) { + cut_rhs += aj * lower_bounds[j]; + cut.x[k] = 0.0; + removed++; + continue; + } else { + } + } + } + + if (removed > 0) + { + sparse_vector_t new_cut(cut.n, 0); + cut.squeeze(new_cut); + cut = new_cut; + } +} + +template +i_t mixed_integer_rounding_cut_t::generate_cut_nonnegative( + const sparse_vector_t& a, + f_t beta, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + + auto f = [](f_t q_1, f_t q_2) -> f_t { + f_t q_1_hat = q_1 - std::floor(q_1); + f_t q_2_hat = q_2 - std::floor(q_2); + return std::min(q_1_hat, q_2_hat) + q_2_hat * std::floor(q_1); + }; + + auto h = [](f_t q) -> f_t { return std::max(q, 0.0); }; + + std::vector cut_indices; + cut_indices.reserve(a.i.size()); + f_t R = (beta - std::floor(beta)) * std::ceil(beta); + + for (i_t k = 0; k < a.i.size(); k++) { + const i_t jj = a.i[k]; + f_t aj = a.x[k]; + if (var_types[jj] == variable_type_t::INTEGER) { + x_workspace_[jj] += f(aj, beta); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } else { + x_workspace_[jj] += h(aj); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } + } + + cut.i.reserve(cut_indices.size()); + cut.x.reserve(cut_indices.size()); + cut.i.clear(); + cut.x.clear(); + for (i_t k = 0; k < cut_indices.size(); k++) { + const i_t j = cut_indices[k]; + cut.i.push_back(j); + cut.x.push_back(x_workspace_[j]); + } + + // Clear the workspace + for (i_t jj : cut_indices) { + x_workspace_[jj] = 0.0; + x_mark_[jj] = 0; + } + + +#ifdef CHECK_WORKSPACE + for (i_t j = 0; j < x_workspace_.size(); j++) { + if (x_workspace_[j] != 0.0) { + printf("After generate_cut: Dirty x_workspace_[%d] = %e\n", j, x_workspace_[j]); + assert(x_workspace_[j] == 0.0); + } + if (x_mark_[j] != 0) { + printf("After generate_cut: Dirty x_mark_[%d] = %d\n", j, x_mark_[j]); + assert(x_mark_[j] == 0); + } + } +#endif + + // The new cut is: g'*x >= R + // But we want to have it in the form h'*x <= b + cut.sort(); + + cut_rhs = R; + +#ifdef CHECK_REPEATED_INDICES + // Check for repeated indicies + std::vector check(num_vars_, 0); + for (i_t p = 0; p < cut.i.size(); p++) + { + if (check[cut.i[p]] != 0) + { + printf("repeated index in generated cut\n"); + assert(check[cut.i[p]] == 0); + } + check[cut.i[p]] = 1; + } +#endif + + if (cut.i.size() == 0) { + return -1; + } + + return 0; +} + +template +i_t mixed_integer_rounding_cut_t::generate_cut( + const sparse_vector_t& a, + f_t beta, + const std::vector& upper_bounds, + const std::vector& lower_bounds, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs) +{ +#ifdef CHECK_WORKSPACE + for (i_t j = 0; j < x_workspace_.size(); j++) { + if (x_workspace_[j] != 0.0) { + printf("Before generate_cut: Dirty x_workspace_[%d] = %e\n", j, x_workspace_[j]); + printf("num_vars_ %d\n", num_vars_); + printf("x_workspace_.size() %ld\n", x_workspace_.size()); + assert(x_workspace_[j] == 0.0); + } + if (x_mark_[j] != 0) { + printf("Before generate_cut: Dirty x_mark_[%d] = %d\n", j, x_mark_[j]); + assert(x_mark_[j] == 0); + } + } +#endif + + + auto f = [](f_t q_1, f_t q_2) -> f_t { + f_t q_1_hat = q_1 - std::floor(q_1); + f_t q_2_hat = q_2 - std::floor(q_2); + return std::min(q_1_hat, q_2_hat) + q_2_hat * std::floor(q_1); + }; + + auto h = [](f_t q) -> f_t { return std::max(q, 0.0); }; + + std::vector cut_indices; + cut_indices.reserve(a.i.size()); + f_t R; + if (!needs_complement_) { + R = (beta - std::floor(beta)) * std::ceil(beta); + + for (i_t k = 0; k < a.i.size(); k++) { + const i_t jj = a.i[k]; + f_t aj = a.x[k]; + if (var_types[jj] == variable_type_t::INTEGER) { + x_workspace_[jj] += f(aj, beta); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } else { + x_workspace_[jj] += h(aj); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } + } + } else { + // Compute r + f_t r = beta; + for (i_t k = 0; k < a.i.size(); k++) { + const i_t jj = a.i[k]; + if (has_upper_[jj]) { + const f_t uj = upper_bounds[jj]; + r -= uj * a.x[k]; + continue; + } + if (has_lower_[jj]) { + const f_t lj = lower_bounds[jj]; + r -= lj * a.x[k]; + } + } + + // Compute R + R = std::ceil(r) * (r - std::floor(r)); + for (i_t k = 0; k < a.i.size(); k++) { + const i_t jj = a.i[k]; + const f_t aj = a.x[k]; + if (has_upper_[jj]) { + const f_t uj = upper_bounds[jj]; + if (var_types[jj] == variable_type_t::INTEGER) { + R -= f(-aj, r) * uj; + } else { + R -= h(-aj) * uj; + } + } else if (has_lower_[jj]) { + const f_t lj = lower_bounds[jj]; + if (var_types[jj] == variable_type_t::INTEGER) { + R += f(aj, r) * lj; + } else { + R += h(aj) * lj; + } + } + } + + // Compute the cut coefficients + for (i_t k = 0; k < a.i.size(); k++) { + const i_t jj = a.i[k]; + const f_t aj = a.x[k]; + if (has_upper_[jj]) { + if (var_types[jj] == variable_type_t::INTEGER) { + // Upper intersect I + x_workspace_[jj] -= f(-aj, r); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } else { + // Upper intersect C + f_t h_j = h(-aj); + if (h_j != 0.0) { + x_workspace_[jj] -= h_j; + if (!x_mark_[jj]) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } + } + } else if (var_types[jj] == variable_type_t::INTEGER) { + // I \ Upper + x_workspace_[jj] += f(aj, r); + if (!x_mark_[jj] && x_workspace_[jj] != 0.0) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } else { + // C \ Upper + f_t h_j = h(aj); + if (h_j != 0.0) { + x_workspace_[jj] += h_j; + if (!x_mark_[jj]) { + x_mark_[jj] = 1; + cut_indices.push_back(jj); + } + } + } + } + } + + cut.i.reserve(cut_indices.size()); + cut.x.reserve(cut_indices.size()); + cut.i.clear(); + cut.x.clear(); + for (i_t k = 0; k < cut_indices.size(); k++) { + const i_t jj = cut_indices[k]; + + // Check for small coefficients + const f_t aj = x_workspace_[jj]; + if (std::abs(aj) < 1e-6) { + if (aj >= 0.0 && upper_bounds[jj] < inf) { + // Move this to the right-hand side + R -= aj * upper_bounds[jj]; + continue; + } else if (aj <= 0.0 && lower_bounds[jj] > -inf) { + R += aj * lower_bounds[jj]; + continue; + } else { + } + } + cut.i.push_back(jj); + cut.x.push_back(x_workspace_[jj]); + } + + // Clear the workspace + for (i_t jj : cut_indices) { + x_workspace_[jj] = 0.0; + x_mark_[jj] = 0; + } + + +#ifdef CHECK_WORKSPACE + for (i_t j = 0; j < x_workspace_.size(); j++) { + if (x_workspace_[j] != 0.0) { + printf("After generate_cut: Dirty x_workspace_[%d] = %e\n", j, x_workspace_[j]); + assert(x_workspace_[j] == 0.0); + } + if (x_mark_[j] != 0) { + printf("After generate_cut: Dirty x_mark_[%d] = %d\n", j, x_mark_[j]); + assert(x_mark_[j] == 0); + } + } +#endif + + // The new cut is: g'*x >= R + // But we want to have it in the form h'*x <= b + cut.sort(); + + cut_rhs = R; + +#ifdef CHECK_REPEATED_INDICES + // Check for repeated indicies + std::vector check(num_vars_, 0); + for (i_t p = 0; p < cut.i.size(); p++) + { + if (check[cut.i[p]] != 0) + { + printf("repeated index in generated cut\n"); + assert(check[cut.i[p]] == 0); + } + check[cut.i[p]] = 1; + } +#endif + + if (cut.i.size() == 0) { + return -1; + } + + return 0; +} + +template +void mixed_integer_rounding_cut_t::substitute_slacks(const lp_problem_t& lp, + csr_matrix_t& Arow, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + // Remove slacks from the cut + // So that the cut is only over the original variables + bool found_slack = false; + i_t cut_nz = 0; + std::vector cut_indices; + cut_indices.reserve(cut.i.size()); + +#ifdef CHECK_WORKSPACE + for (i_t j = 0; j < x_workspace_.size(); j++) { + if (x_workspace_[j] != 0.0) { + printf("Begin Dirty x_workspace_[%d] = %e\n", j, x_workspace_[j]); + assert(x_workspace_[j] == 0.0); + } + if (x_mark_[j] != 0) { + printf("Begin Dirty x_mark_[%d] = %d\n", j, x_mark_[j]); + assert(x_mark_[j] == 0); + } + } +#endif + + + + for (i_t k = 0; k < cut.i.size(); k++) { + const i_t j = cut.i[k]; + const f_t cj = cut.x[k]; + if (is_slack_[j]) { + found_slack = true; + const i_t slack_start = lp.A.col_start[j]; + const i_t slack_end = lp.A.col_start[j + 1]; + const i_t slack_len = slack_end - slack_start; + if (slack_len != 1) { + printf("Slack %d has %d nzs in colum\n", j, slack_len); + assert(slack_len == 1); + } + const f_t alpha = lp.A.x[slack_start]; + if (std::abs(alpha) != 1.0) { + printf("Slack %d has non-unit coefficient %e\n", j, alpha); + assert(std::abs(alpha) == 1.0); + } + + // Do the substitution + // Slack variable s_j participates in row i of the constraint matrix + // Row i is of the form: + // sum_{k != j} A(i, k) * x_k + alpha * s_j = rhs_i + // where alpha = +1/-1 + /// So we have that + // s_j = (rhs_i - sum_{k != j} A(i, k) * x_k)/alpha + + // Our cut is of the form: + // sum_{k != j} C(k) * x_k + C(j) * s_j >= cut_rhs + // So the cut becomes + // sum_{k != j} C(k) * x_k + C(j)/alpha * (rhs_i - sum_{h != j} A(i, h) * x_h) >= cut_rhs + // This is equivalent to: + // sum_{k != j} C(k) * x_k + sum_{h != j} -C(j)/alpha * A(i, h) * x_h >= cut_rhs - C(j)/alpha * rhs_i + const i_t i = slack_rows_[j]; + //printf("Found slack %d in cut. lo %e up %e. Slack row %d\n", j, lp.lower[j], lp.upper[j], i); + cut_rhs -= cj * lp.rhs[i] / alpha; + const i_t row_start = Arow.row_start[i]; + const i_t row_end = Arow.row_start[i + 1]; + for (i_t q = row_start; q < row_end; q++) { + const i_t h = Arow.j[q]; + if (h != j) { + const f_t aih = Arow.x[q]; + x_workspace_[h] -= cj * aih / alpha; + if (!x_mark_[h]) { + x_mark_[h] = 1; + cut_indices.push_back(h); + cut_nz++; + } + } else { + const f_t aij = Arow.x[q]; + if (std::abs(aij)!= 1.0) { + printf("Slack row %d has non-unit coefficient %e for variable %d\n", i, aij, j); + assert(std::abs(aij) == 1.0); + } + } + } + + } else { + x_workspace_[j] += cj; + if (!x_mark_[j]) { + x_mark_[j] = 1; + cut_indices.push_back(j); + cut_nz++; + } + } + } + + if (found_slack) { + //printf("Found slack. Nz increased from %d to %d: %d\n", cut.i.size(), cut_nz, cut_nz - cut.i.size()); + cut.i.reserve(cut_nz); + cut.x.reserve(cut_nz); + cut.i.clear(); + cut.x.clear(); + + for (i_t k = 0; k < cut_nz; k++) { + const i_t j = cut_indices[k]; + + // Check for small coefficients + const f_t aj = x_workspace_[j]; + if (std::abs(aj) < 1e-6) { + if (aj >= 0.0 && lp.upper[j] < inf) { + // Move this to the right-hand side + cut_rhs -= aj * lp.upper[j]; + continue; + } else if (aj <= 0.0 && lp.lower[j] > -inf) { + cut_rhs += aj * lp.lower[j]; + continue; + } else { + } + } + + cut.i.push_back(j); + cut.x.push_back(x_workspace_[j]); + } + // Sort the cut + cut.sort(); + } + + // Clear the workspace + for (i_t jj : cut_indices) { + x_workspace_[jj] = 0.0; + x_mark_[jj] = 0; + } + + +#ifdef CHECK_WORKSPACE + for (i_t j = 0; j < x_workspace_.size(); j++) { + if (x_workspace_[j] != 0.0) { + printf("End Dirty x_workspace_[%d] = %e\n", j, x_workspace_[j]); + assert(x_workspace_[j] == 0.0); + } + if (x_mark_[j] != 0) { + printf("End Dirty x_mark_[%d] = %d\n", j, x_mark_[j]); + assert(x_mark_[j] == 0); + } + } +#endif +} + +template +f_t mixed_integer_rounding_cut_t::compute_violation(const sparse_vector_t& cut, + f_t cut_rhs, + const std::vector& xstar) +{ + f_t dot = cut.dot(xstar); + f_t cut_violation = cut_rhs - dot; + return cut_violation; +} + +template +void mixed_integer_rounding_cut_t::combine_rows(const lp_problem_t& lp, + csr_matrix_t& Arow, + i_t xj, + const sparse_vector_t& pivot_row, + f_t pivot_row_rhs, + sparse_vector_t& inequality, + f_t& inequality_rhs) +{ + +#ifdef CHECK_WORKSPACE + for (i_t k = 0; k < x_workspace_.size(); k++) { + if (x_workspace_[k] != 0.0) { + printf("Dirty x_workspace_[%d] = %e\n", k, x_workspace_[k]); + assert(x_workspace_[k] == 0.0); + } + if (x_mark_[k] != 0) { + printf("Dirty x_mark_[%d] = %d\n", k, x_mark_[k]); + assert(x_mark_[k] == 0); + } + } +#endif + + indices_.clear(); + indices_.reserve(pivot_row.i.size() + inequality.i.size()); + + // Find the coefficient associated with variable xj in the pivot row + f_t a_l_j = 0.0; + for (i_t k = 0; k < pivot_row.i.size(); k++) { + const i_t j = pivot_row.i[k]; + if (j == xj) { + a_l_j = pivot_row.x[k]; + break; + } + } + + if (a_l_j == 0) + { + return; + } + + f_t a_i_j = 0.0; + + i_t nz = 0; + // Store the inequality in the workspace + // and save the coefficient associated with variable xj + for (i_t k = 0; k < inequality.i.size(); k++) { + const i_t j = inequality.i[k]; + if (j != xj) { + x_workspace_[j] = inequality.x[k]; + x_mark_[j] = 1; + indices_.push_back(j); + nz++; + } else { + a_i_j = inequality.x[k]; + } + } + + f_t pivot_value = a_i_j / a_l_j; + // Adjust the rhs of the inequality + inequality_rhs -= pivot_value * pivot_row_rhs; + + // Adjust the coefficients of the inequality + // based on the nonzeros in the pivot row + for (i_t k = 0; k < pivot_row.i.size(); k++) { + const i_t j = pivot_row.i[k]; + if (j != xj) { + x_workspace_[j] -= pivot_value * pivot_row.x[k]; + if (!x_mark_[j]) { + x_mark_[j] = 1; + indices_.push_back(j); + nz++; + } + } + } + + // Store the new inequality + inequality.i.resize(nz); + inequality.x.resize(nz); + for (i_t k = 0; k < nz; k++) { + inequality.i[k] = indices_[k]; + inequality.x[k] = x_workspace_[indices_[k]]; + } + +#ifdef CHECK_REPEATED_INDICES + // Check for repeated indices + std::vector check(num_vars_, 0); + for (i_t k = 0; k < inequality.i.size(); k++) + { + if (check[inequality.i[k]] == 1) { + printf("repeated index\n"); + assert(check[inequality.i[k]] == 0); + } + check[inequality.i[k]] = 1; + } +#endif + + // Clear the workspace + for (i_t j : indices_) { + x_workspace_[j] = 0.0; + x_mark_[j] = 0; + } + indices_.clear(); +} + +template +strong_cg_cut_t::strong_cg_cut_t(const lp_problem_t& lp, + const std::vector& var_types, + const std::vector& xstar) + : transformed_variables_(lp.num_cols, 0) +{ + // Determine the substition for the integer variables + for (i_t j = 0; j < lp.num_cols; j++) { + if (var_types[j] == variable_type_t::INTEGER) { + const f_t l_j = lp.lower[j]; + const f_t u_j = lp.upper[j]; + if (l_j != 0.0) { + // We need to transform the variable + // Check the distance to each bound + const f_t dist_to_lower = std::max(0.0, xstar[j] - l_j); + const f_t dist_to_upper = std::max(0.0, u_j - xstar[j]); + if (dist_to_upper >= dist_to_lower || u_j >= inf) { + // We are closer to the lower bound. + transformed_variables_[j] = -1; + } else if (u_j < inf) { + // We are closer to the finite upper bound + transformed_variables_[j] = 1; + } + } + } + } +} + +template +i_t strong_cg_cut_t::remove_continuous_variables_integers_nonnegative( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + sparse_vector_t& inequality, + f_t& inequality_rhs) +{ + const bool verbose = false; + // Count the number of continuous variables in the inequality + i_t num_continuous = 0; + const i_t nz = inequality.i.size(); + for (i_t k = 0; k < nz; k++) { + const i_t j = inequality.i[k]; + if (var_types[j] == variable_type_t::CONTINUOUS) { + num_continuous++; + } + } + + if (verbose) { + settings.log.printf("num_continuous %d\n", num_continuous); + } + // We assume the inequality is of the form sum_j a_j x_j <= rhs + + for (i_t k = 0; k < nz; k++) { + const i_t j = inequality.i[k]; + const f_t l_j = lp.lower[j]; + const f_t u_j = lp.upper[j]; + const f_t a_j = inequality.x[k]; + if (var_types[j] == variable_type_t::CONTINUOUS) { + if (a_j == 0.0) { + continue; + } + + if (a_j > 0.0 && l_j > -inf) { + // v_j = x_j - l_j >= 0 + // x_j = v_j + l_j + // sum_{k != j} a_k x_k + a_j x_j <= rhs + // sum_{k != j} a_k x_k + a_j (v_j + l_j) <= rhs + // sum_{k != j} a_k x_k + a_j v_j <= rhs - a_j l_j + inequality_rhs -= a_j * l_j; + transformed_variables_[j] = -1; + + // We now have a_j * v_j with a_j, v_j >= 0 + // So we have sum_{k != j} a_k x_k <= sum_{k != j} a_k x_k + a_j v_j <= rhs - a_j l_j + // So we can now drop the continuous variable v_j + inequality.x[k] = 0.0; + + } else if (a_j < 0.0 && u_j < inf) { + // w_j = u_j - x_j >= 0 + // x_j = u_j - w_j + // sum_{k != j} a_k x_k + a_j x_j <= rhs + // sum_{k != j} a_k x_k + a_j (u_j - w_j) <= rhs + // sum_{k != j} a_k x_k - a_j w_j <= rhs - a_j u_j + inequality_rhs -= a_j * u_j; + transformed_variables_[j] = 1; + + // We now have a_j * w_j with a_j, w_j >= 0 + // So we have sum_{k != j} a_k x_k <= sum_{k != j} a_k x_k + a_j w_j <= rhs - a_j u_j + // So we can now drop the continuous variable w_j + inequality.x[k] = 0.0; + } else { + // We can't keep the coefficient of the continuous variable positive + // This means we can't eliminate the continuous variable + if (verbose) { + settings.log.printf("x%d ak: %e lo: %e up: %e\n", j, a_j, l_j, u_j); + } + return -1; + } + } else { + // The variable is integer. We just need to ensure it is nonnegative + if (transformed_variables_[j] == -1) { + // We are closer to the lower bound. + // v_j = x_j - l_j >= 0 + // x_j = v_j + l_j + // sum_{k != j} a_k x_k + a_j x_j <= rhs + // sum_{k != j} a_k x_k + a_j (v_j + l_j) <= rhs + // sum_{k != j} a_k x_k + a_j v_j <= rhs - a_j l_j + inequality_rhs -= a_j * l_j; + } else if (transformed_variables_[j] == 1) { + // We are closer to the finite upper bound + // w_j = u_j - x_j >= 0 + // x_j = u_j - w_j + // sum_{k != j} a_k x_k + a_j x_j <= rhs + // sum_{k != j} a_k x_k + a_j (u_j - w_j) <= rhs + // sum_{k != j} a_k x_k - a_j w_j <= rhs - a_j u_j + inequality_rhs -= a_j * u_j; + inequality.x[k] *= -1.0; + } + } + } + + // Squeeze out the zero coefficents + sparse_vector_t new_inequality(inequality.n, 0); + inequality.squeeze(new_inequality); + inequality = new_inequality; + return 0; +} + +template +void strong_cg_cut_t::to_original_integer_variables( + const lp_problem_t& lp, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + // We expect a cut of the form sum_j a_j y_j <= rhs + // where y_j >= 0 is a transformed variable + // We need to convert it back into a cut on the original variables + + for (i_t k = 0; k < cut.i.size(); k++) { + const i_t j = cut.i[k]; + const f_t a_j = cut.x[k]; + if (transformed_variables_[j] == -1) { + // sum_{k != j} a_k x_k + a_j v_j <= rhs + // v_j = x_j - l_j >= 0, + // sum_{k != j} a_k x_k + a_j (x_j - l_j) <= rhs + // sum_{k != j} a_k x_k + a_j x_j <= rhs + a_j l_j + cut_rhs += a_j * lp.lower[j]; + } else if (transformed_variables_[j] == 1) { + // sum_{k != j} a_k x_k + a_j w_j <= rhs + // w_j = u_j - x_j >= 0 + // sum_{k != j} a_k x_k + a_j (u_j - x_j) <= rhs + // sum_{k != j} a_k x_k - a_j x_j <= rhs - a_j u_j + cut_rhs -= a_j * lp.upper[j]; + cut.x[k] *= -1.0; + } + } +} + +template +i_t strong_cg_cut_t::generate_strong_cg_cut_integer_only( + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const sparse_vector_t& inequality, + f_t inequality_rhs, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + // We expect an inequality of the form sum_j a_j x_j <= rhs + // where all the variables x_j are integer and nonnegative + + // We then apply the CG cut: + // sum_j floor(a_j) x_j <= floor(rhs) + cut.i.reserve(inequality.i.size()); + cut.x.reserve(inequality.i.size()); + cut.i.clear(); + cut.x.clear(); + + f_t a_0 = inequality_rhs; + f_t f_a_0 = fractional_part(a_0); + + if (f_a_0 == 0.0) { + // f(a_0) == 0.0 so we do a weak CG cut + cut.i.reserve(inequality.i.size()); + cut.x.reserve(inequality.i.size()); + cut.i.clear(); + cut.x.clear(); + for (i_t k = 0; k < inequality.i.size(); k++) { + const i_t j = inequality.i[k]; + const f_t a_j = inequality.x[k]; + if (var_types[j] == variable_type_t::INTEGER) { + cut.i.push_back(j); + cut.x.push_back(std::floor(a_j)); + } else { + return -1; + } + } + cut_rhs = std::floor(inequality_rhs); + } else { + return generate_strong_cg_cut_helper( + inequality.i, inequality.x, inequality_rhs, var_types, cut, cut_rhs); + } + return 0; +} + +template +i_t strong_cg_cut_t::generate_strong_cg_cut_helper( + const std::vector& indicies, + const std::vector& coefficients, + f_t rhs, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs) +{ + const bool verbose = false; + const i_t nz = indicies.size(); + const f_t f_a_0 = fractional_part(rhs); + + const f_t min_fractional_part = 1e-2; + if (f_a_0 < min_fractional_part) { + return -1; + } + if (f_a_0 > 1 - min_fractional_part) { + return -1; + } + + // We will try to generat a strong CG cut. + // Find the unique integer k such that + // 1/(k+1) <= f(a_0) < 1/k + f_t k_upper = 1.0 / f_a_0; + i_t k = static_cast(std::floor(k_upper)); + if (k_upper - static_cast(k) < 1e-6) { + k--; + if (verbose) { + printf("Decreased k to %d\n", k); + } + } + + const f_t alpha = 1.0 - f_a_0; + f_t lower = 1.0 / static_cast(k + 1); + f_t upper = 1.0 / static_cast(k); + if (verbose) { + printf("f_a_0 %e lower %e upper %e alpha %e\n", f_a_0, lower, upper, alpha); + } + if (f_a_0 >= lower && f_a_0 < upper) { + cut.i.reserve(nz); + cut.x.reserve(nz); + cut.i.clear(); + cut.x.clear(); + for (i_t q = 0; q < nz; q++) { + const i_t j = indicies[q]; + const f_t a_j = coefficients[q]; + if (var_types[j] == variable_type_t::INTEGER) { + const f_t f_a_j = fractional_part(a_j); + if (f_a_j <= f_a_0) { + cut.i.push_back(j); + cut.x.push_back((k + 1.0) * std::floor(a_j)); + if (verbose) { + printf("j %d a_j %e f_a_j %e k %d\n", j, a_j, f_a_j, k); + } + } else { + // Need to compute the p such that + // f(a_0) + (p-1)/k * alpha < f(a_j) <= f(a_0) + p/k * alpha + const f_t value = static_cast(k) * (f_a_j - f_a_0) / alpha; + if (value < 1e-6) { + return -1; // Safegaurd to prevent numerical issues when f(a_j) is very close to f(a_0) + // You might also be able to adjust p here to avoid this issue + } + i_t p = static_cast(std::ceil(value)); + if (fractional_part(value) < 1e-12) { + //printf("Warning: p %d value %.16e is close to an integer\n", p, value, p + 1); + } + if (verbose) { + printf("j %d a_j %e f_a_j %e p %d value %.16e\n", j, a_j, f_a_j, p, value); + } + if (f_a_0 + static_cast(p - 1) / static_cast(k) * alpha < f_a_j && + f_a_j <= f_a_0 + static_cast(p) / static_cast(k) * alpha) { + cut.i.push_back(j); + cut.x.push_back((k + 1.0) * std::floor(a_j) + p); + } else { + printf("Error: p %d f_a_0 %e f_a_j %e alpha %e value %.16e\n", p, f_a_0, f_a_j, alpha, value); + return -1; + } + } + } else { + return -1; + } + } + } else { + printf("Error: k %d lower %e f(a_0) %e upper %e\n", k, lower, f_a_0, upper); + return -1; + } + cut_rhs = (k + 1.0) * std::floor(rhs); + if (verbose) { + printf("Generated strong CG cut: k %d f_a_0 %e cut_rhs %e\n", k, f_a_0, cut_rhs); + for (i_t q = 0; q < cut.i.size(); q++) { + if (cut.x[q] != 0.0) { + printf("%.16e x%d ", cut.x[q], cut.i[q]); + } + } + printf("\n"); + printf("Original inequality rhs %e nz %d\n", rhs, coefficients.size()); + for (i_t q = 0; q < nz; q++) { + printf("%e x%d ", coefficients[q], indicies[q]); + } + printf("\n"); + } + return 0; +} + +template +i_t strong_cg_cut_t::generate_strong_cg_cut( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const sparse_vector_t& inequality, + const f_t inequality_rhs, + const std::vector& xstar, + sparse_vector_t& cut, + f_t& cut_rhs) +{ +#ifdef PRINT_INEQUALITY_INFO + for (i_t k = 0; k < inequality.i.size(); k++) { + printf("%e %c%d ", + inequality.x[k], + var_types[inequality.i[k]] == variable_type_t::CONTINUOUS ? 'x' : 'y', + inequality.i[k]); + } + printf("CG inequality rhs %e\n", inequality_rhs); +#endif + // Try to remove continuous variables from the inequality + // and transform integer variables to be nonnegative + + // Copy the inequality since remove continuous variables will modify it + sparse_vector_t cg_inequality = inequality; + f_t cg_inequality_rhs = inequality_rhs; + i_t status = remove_continuous_variables_integers_nonnegative( + lp, settings, var_types, cg_inequality, cg_inequality_rhs); + + if (status != 0) { + // Try negating the equality and see if that helps + cg_inequality = inequality; + cg_inequality.negate(); + cg_inequality_rhs = -inequality_rhs; + + status = remove_continuous_variables_integers_nonnegative( + lp, settings, var_types, cg_inequality, cg_inequality_rhs); + } + + if (status == 0) { + // We have an inequality with no continuous variables + + // Generate a CG cut + status = generate_strong_cg_cut_integer_only( + settings, var_types, cg_inequality, cg_inequality_rhs, cut, cut_rhs); + if (status != 0) { + return -1; + } + + // Convert the CG cut back to the original variables + to_original_integer_variables(lp, cut, cut_rhs); + + // Check for violation + f_t dot = cut.dot(xstar); + // If the cut is violated we will have: sum_j a_j xstar_j > rhs + f_t violation = dot - cut_rhs; + const f_t min_violation_threshold = 1e-6; + if (violation > min_violation_threshold) { + //printf("CG violation %e nz %ld\n", violation, cut.i.size()); + // Note that no slacks are currently present. Since slacks are currently treated as continuous. + // However, this may change. We may need to substitute out the slacks here + + + // The CG cut is in the form: sum_j a_j x_j <= rhs + // The cut pool wants the cut in the form: sum_j a_j x_j >= rhs + cut.negate(); + cut_rhs *= -1.0; + return 0; + } + } + return -1; +} + +template +i_t add_cuts(const simplex_solver_settings_t& settings, + const csr_matrix_t& cuts, + const std::vector& cut_rhs, + lp_problem_t& lp, + std::vector& new_slacks, + lp_solution_t& solution, + basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& vstatus, + std::vector& edge_norms) + +{ + // Given a set of cuts: C*x <= d that are currently violated + // by the current solution x* (i.e. C*x* > d), this function + // adds the cuts into the LP and solves again. + +#ifdef CHECK_BASIS + { + csc_matrix_t Btest(lp.num_rows, lp.num_rows, 1); + basis_update.multiply_lu(Btest); + csc_matrix_t B(lp.num_rows, lp.num_rows, 1); + form_b(lp.A, basic_list, B); + csc_matrix_t Diff(lp.num_rows, lp.num_rows, 1); + add(Btest, B, 1.0, -1.0, Diff); + const f_t err = Diff.norm1(); + settings.log.printf("Before || B - L*U || %e\n", err); + assert(err <= 1e-6); + } +#endif + + const i_t p = cuts.m; + if (cut_rhs.size() != static_cast(p)) { + settings.log.printf("cut_rhs must have the same number of rows as cuts\n"); + assert(cut_rhs.size() == static_cast(p)); + } + settings.log.debug("Number of cuts %d\n", p); + settings.log.debug("Original lp rows %d\n", lp.num_rows); + settings.log.debug("Original lp cols %d\n", lp.num_cols); + + csr_matrix_t new_A_row(lp.num_rows, lp.num_cols, 1); + lp.A.to_compressed_row(new_A_row); + + i_t append_status = new_A_row.append_rows(cuts); + if (append_status != 0) { + settings.log.printf("append_rows error: %d\n", append_status); + assert(append_status == 0); + } + + csc_matrix_t new_A_col(lp.num_rows + p, lp.num_cols, 1); + new_A_row.to_compressed_col(new_A_col); + + // Add in slacks variables for the new rows + lp.lower.resize(lp.num_cols + p); + lp.upper.resize(lp.num_cols + p); + lp.objective.resize(lp.num_cols + p); + i_t nz = new_A_col.col_start[lp.num_cols]; + new_A_col.col_start.resize(lp.num_cols + p + 1); + new_A_col.i.resize(nz + p); + new_A_col.x.resize(nz + p); + i_t k = lp.num_rows; + for (i_t j = lp.num_cols; j < lp.num_cols + p; j++) { + new_A_col.col_start[j] = nz; + new_A_col.i[nz] = k++; + new_A_col.x[nz] = 1.0; + nz++; + lp.lower[j] = 0.0; + lp.upper[j] = inf; + lp.objective[j] = 0.0; + new_slacks.push_back(j); + } + settings.log.debug("Done adding slacks\n"); + new_A_col.col_start[lp.num_cols + p] = nz; + new_A_col.n = lp.num_cols + p; + + lp.A = new_A_col; + + // Check that all slack columns have length 1 + for (i_t slack: new_slacks) { + const i_t col_start = lp.A.col_start[slack]; + const i_t col_end = lp.A.col_start[slack + 1]; + const i_t col_len = col_end - col_start; + if (col_len != 1) { + settings.log.printf("Add cuts: Slack %d has %d nzs in column\n", slack, col_len); + assert(col_len == 1); + } + } + + + i_t old_rows = lp.num_rows; + lp.num_rows += p; + i_t old_cols = lp.num_cols; + lp.num_cols += p; + + lp.rhs.resize(lp.num_rows); + for (i_t k = old_rows; k < old_rows + p; k++) { + const i_t h = k - old_rows; + lp.rhs[k] = cut_rhs[h]; + } + settings.log.debug("Done adding rhs\n"); + + // Construct C_B = C(:, basic_list) + std::vector C_col_degree(lp.num_cols, 0); + i_t cuts_nz = cuts.row_start[p]; + for (i_t q = 0; q < cuts_nz; q++) { + const i_t j = cuts.j[q]; + if (j >= lp.num_cols) { + settings.log.printf("j %d is greater than p %d\n", j, p); + return -1; + } + C_col_degree[j]++; + } + settings.log.debug("Done computing C_col_degree\n"); + + std::vector in_basis(old_cols, -1); + const i_t num_basic = static_cast(basic_list.size()); + i_t C_B_nz = 0; + for (i_t k = 0; k < num_basic; k++) { + const i_t j = basic_list[k]; + if (j < 0 || j >= old_cols) { + settings.log.printf( + "basic_list[%d] = %d is out of bounds %d old_cols %d\n", k, j, j, old_cols); + assert(j >= 0 && j < old_cols); + } + in_basis[j] = k; + // The cuts are on the original variables. So it is possible that + // a slack will be basic and thus not part of the cuts matrix + if (j < cuts.n) { C_B_nz += C_col_degree[j]; } + } + settings.log.debug("Done estimating C_B_nz\n"); + + csr_matrix_t C_B(p, num_basic, C_B_nz); + nz = 0; + for (i_t i = 0; i < p; i++) { + C_B.row_start[i] = nz; + const i_t row_start = cuts.row_start[i]; + const i_t row_end = cuts.row_start[i + 1]; + for (i_t q = row_start; q < row_end; q++) { + const i_t j = cuts.j[q]; + const i_t j_basis = in_basis[j]; + if (j_basis == -1) { continue; } + C_B.j[nz] = j_basis; + C_B.x[nz] = cuts.x[q]; + nz++; + } + } + C_B.row_start[p] = nz; + + if (nz != C_B_nz) { + settings.log.printf("Add cuts: predicted nz %d actual nz %d\n", C_B_nz, nz); + assert(nz == C_B_nz); + } + settings.log.debug("C_B rows %d cols %d nz %d\n", C_B.m, C_B.n, nz); + + // Adjust the basis update to include the new cuts + basis_update.append_cuts(C_B); + + basic_list.resize(lp.num_rows, 0); + i_t h = old_cols; + for (i_t j = old_rows; j < lp.num_rows; j++) { + basic_list[j] = h++; + } + +#ifdef CHECK_BASIS + // Check the basis update + csc_matrix_t Btest(lp.num_rows, lp.num_rows, 1); + basis_update.multiply_lu(Btest); + + csc_matrix_t B(lp.num_rows, lp.num_rows, 1); + form_b(lp.A, basic_list, B); + + csc_matrix_t Diff(lp.num_rows, lp.num_rows, 1); + add(Btest, B, 1.0, -1.0, Diff); + const f_t err = Diff.norm1(); + settings.log.printf("After || B - L*U || %e\n", err); + if (err > 1e-6) { + settings.log.printf("Diff matrix\n"); + // Diff.print_matrix(); + assert(err <= 1e-6); + } +#endif + // Adjust the vstatus + vstatus.resize(lp.num_cols); + for (i_t j = old_cols; j < lp.num_cols; j++) { + vstatus[j] = variable_status_t::BASIC; + } + + return 0; +} + +template +void remove_cuts(lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + std::vector& new_slacks, + i_t original_rows, + std::vector& var_types, + std::vector& vstatus, + std::vector& x, + std::vector& y, + std::vector& z, + std::vector& basic_list, + std::vector& nonbasic_list, + basis_update_mpf_t& basis_update) +{ + std::vector cuts_to_remove; + cuts_to_remove.reserve(lp.num_rows - original_rows); + std::vector slacks_to_remove; + slacks_to_remove.reserve(lp.num_rows - original_rows); + const f_t dual_tol = 1e-10; + + std::vector is_slack(lp.num_cols, 0); + for (i_t j : new_slacks) { + is_slack[j] = 1; + // Check that slack column length is 1 + const i_t col_start = lp.A.col_start[j]; + const i_t col_end = lp.A.col_start[j + 1]; + const i_t col_len = col_end - col_start; + if (col_len != 1) { + printf("Remove cuts: Slack %d has %d nzs in column\n", j, col_len); + assert(col_len == 1); + } + } + + for (i_t k = original_rows; k < lp.num_rows; k++) { + if (std::abs(y[k]) < dual_tol) { + const i_t row_start = Arow.row_start[k]; + const i_t row_end = Arow.row_start[k + 1]; + i_t last_slack = -1; + const f_t slack_tol = 1e-3; + for (i_t p = row_start; p < row_end; p++) { + const i_t j = Arow.j[p]; + if (is_slack[j]) { + if (vstatus[j] == variable_status_t::BASIC && x[j] > slack_tol) { last_slack = j; } + } + } + if (last_slack != -1) { + cuts_to_remove.push_back(k); + slacks_to_remove.push_back(last_slack); + } + } + } + + if (cuts_to_remove.size() > 0) { + //settings.log.printf("Removing %d cuts\n", cuts_to_remove.size()); + std::vector marked_rows(lp.num_rows, 0); + for (i_t i : cuts_to_remove) { + marked_rows[i] = 1; + } + std::vector marked_cols(lp.num_cols, 0); + for (i_t j : slacks_to_remove) { + marked_cols[j] = 1; + } + + std::vector new_rhs(lp.num_rows - cuts_to_remove.size()); + std::vector new_solution_y(lp.num_rows - cuts_to_remove.size()); + i_t h = 0; + for (i_t i = 0; i < lp.num_rows; i++) { + if (!marked_rows[i]) { + new_rhs[h] = lp.rhs[i]; + new_solution_y[h] = y[i]; + h++; + } + } + csr_matrix_t new_Arow(1, 1, 0); + Arow.remove_rows(marked_rows, new_Arow); + Arow = new_Arow; + Arow.to_compressed_col(lp.A); + + std::vector new_objective(lp.num_cols - slacks_to_remove.size()); + std::vector new_lower(lp.num_cols - slacks_to_remove.size()); + std::vector new_upper(lp.num_cols - slacks_to_remove.size()); + std::vector new_var_types(lp.num_cols - slacks_to_remove.size()); + std::vector new_vstatus(lp.num_cols - slacks_to_remove.size()); + std::vector new_basic_list; + new_basic_list.reserve(lp.num_rows - slacks_to_remove.size()); + std::vector new_nonbasic_list; + new_nonbasic_list.reserve(nonbasic_list.size()); + std::vector new_solution_x(lp.num_cols - slacks_to_remove.size()); + std::vector new_solution_z(lp.num_cols - slacks_to_remove.size()); + std::vector new_is_slacks(lp.num_cols - slacks_to_remove.size(), 0); + h = 0; + for (i_t k = 0; k < lp.num_cols; k++) { + if (!marked_cols[k]) { + new_objective[h] = lp.objective[k]; + new_lower[h] = lp.lower[k]; + new_upper[h] = lp.upper[k]; + new_var_types[h] = var_types[k]; + new_vstatus[h] = vstatus[k]; + new_solution_x[h] = x[k]; + new_solution_z[h] = z[k]; + new_is_slacks[h] = is_slack[k]; + if (new_vstatus[h] != variable_status_t::BASIC) { + new_nonbasic_list.push_back(h); + } else { + new_basic_list.push_back(h); + } + h++; + } + } + lp.A.remove_columns(marked_cols); + lp.A.to_compressed_row(Arow); + lp.objective = new_objective; + lp.lower = new_lower; + lp.upper = new_upper; + lp.rhs = new_rhs; + var_types = new_var_types; + lp.num_cols = lp.A.n; + lp.num_rows = lp.A.m; + + new_slacks.clear(); + new_slacks.reserve(lp.num_cols); + for (i_t j = 0; j < lp.num_cols; j++) { + if (new_is_slacks[j]) { + new_slacks.push_back(j); + } + } + basic_list = new_basic_list; + nonbasic_list = new_nonbasic_list; + vstatus = new_vstatus; + x = new_solution_x; + y = new_solution_y; + z = new_solution_z; + + settings.log.debug("Removed %d cuts. After removal %d rows %d columns %d nonzeros\n", + cuts_to_remove.size(), + lp.num_rows, + lp.num_cols, + lp.A.col_start[lp.A.n]); + + basis_update.resize(lp.num_rows); + basis_update.refactor_basis(lp.A, settings, lp.lower, lp.upper, basic_list, nonbasic_list, vstatus); + } +} + +template +void read_saved_solution_for_cut_verification(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& saved_solution) +{ + settings.log.printf("Trying to open solution.dat\n"); + FILE* fid = NULL; + fid = fopen("solution.dat", "r"); + if (fid != NULL) { + i_t n_solution_dat; + i_t count = fscanf(fid, "%d\n", &n_solution_dat); + settings.log.printf("Solution.dat variables %d =? %d =? count %d\n", + n_solution_dat, + lp.num_cols, + count); + bool good = true; + if (count == 1 && n_solution_dat == lp.num_cols) { + settings.log.printf("Opened solution.dat with %d number of variables\n", n_solution_dat); + saved_solution.resize(n_solution_dat); + for (i_t j = 0; j < n_solution_dat; j++) { + count = fscanf(fid, "%lf", &saved_solution[j]); + if (count != 1) { + settings.log.printf("bad read solution.dat: j %d count %d\n", j, count); + good = false; + break; + } + } + } else { + good = false; + } + fclose(fid); + + if (!good) { + saved_solution.resize(0); + settings.log.printf("Solution.dat is bad\n"); + } else { + settings.log.printf("Read solution file\n"); + + auto hash_combine_f = [](size_t seed, f_t x) { + seed ^= std::hash{}(x) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + return seed; + }; + size_t seed = lp.num_cols; + for (i_t j = 0; j < lp.num_cols; ++j) { + seed = hash_combine_f(seed, saved_solution[j]); + } + settings.log.printf("Saved solution hash: %20x\n", seed); + + // Compute || A * x - b ||_inf + std::vector residual = lp.rhs; + matrix_vector_multiply(lp.A, 1.0, saved_solution, -1.0, residual); + settings.log.printf("Saved solution: || A*x - b ||_inf %e\n", vector_norm_inf(residual)); + f_t infeas = 0; + for (i_t j = 0; j < lp.num_cols; j++) { + if (saved_solution[j] < lp.lower[j] - 1e-6) { + f_t curr_infeas = (lp.lower[j] - saved_solution[j]); + infeas += curr_infeas; + settings.log.printf("j: %d saved solution %e lower %e\n", j, saved_solution[j], lp.lower[j]); + } + if (saved_solution[j] > lp.upper[j] + 1e-6) { + f_t curr_infeas = (saved_solution[j] - lp.upper[j]); + infeas += curr_infeas; + settings.log.printf("j %d saved solution %e upper %e\n", j, saved_solution[j], lp.upper[j]); + } + } + settings.log.printf("Bound infeasibility %e\n", infeas); + } + } else { + settings.log.printf("Could not open solution.dat\n"); + } +} + +#ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE +template class cut_pool_t; +template class cut_generation_t; +template class tableau_equality_t; +template class mixed_integer_rounding_cut_t; + +template +int add_cuts(const simplex_solver_settings_t& settings, + const csr_matrix_t& cuts, + const std::vector& cut_rhs, + lp_problem_t& lp, + std::vector& new_slacks, + lp_solution_t& solution, + basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& vstatus, + std::vector& edge_norms); + +template +void remove_cuts(lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + std::vector& new_slacks, + int original_rows, + std::vector& var_types, + std::vector& vstatus, + std::vector& x, + std::vector& y, + std::vector& z, + std::vector& basic_list, + std::vector& nonbasic_list, + basis_update_mpf_t& basis_update); + +template +void read_saved_solution_for_cut_verification( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& saved_solution); +#endif + +} // namespace cuopt::linear_programming::dual_simplex + + diff --git a/cpp/src/dual_simplex/cuts.hpp b/cpp/src/dual_simplex/cuts.hpp new file mode 100644 index 000000000..a02cd807b --- /dev/null +++ b/cpp/src/dual_simplex/cuts.hpp @@ -0,0 +1,461 @@ +/* clang-format off */ +/* + * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-License-Identifier: Apache-2.0 + */ +/* clang-format on */ +#pragma once + +#include +#include +#include +#include +#include +#include + + +#include + +namespace cuopt::linear_programming::dual_simplex { + +enum cut_type_t : int8_t { + MIXED_INTEGER_GOMORY = 0, + MIXED_INTEGER_ROUNDING = 1, + KNAPSACK = 2, + CHVATAL_GOMORY = 3 +}; + +template +struct cut_info_t { + bool has_cuts() const { return num_gomory_cuts + num_mir_cuts + num_knapsack_cuts + num_cg_cuts > 0; } + i_t num_gomory_cuts = 0; + i_t num_mir_cuts = 0; + i_t num_knapsack_cuts = 0; + i_t num_cg_cuts = 0; +}; + + +template +void print_cut_info(const simplex_solver_settings_t& settings, const cut_info_t& cut_info) +{ + if (cut_info.has_cuts()) { + settings.log.printf("Gomory cuts : %d\n", cut_info.num_gomory_cuts); + settings.log.printf("MIR cuts : %d\n", cut_info.num_mir_cuts); + settings.log.printf("Knapsack cuts : %d\n", cut_info.num_knapsack_cuts); + settings.log.printf("CG cuts : %d\n", cut_info.num_cg_cuts); + } +} + +template +void print_cut_types(const std::string& prefix, + const std::vector& cut_types, + const simplex_solver_settings_t& settings) +{ + i_t num_gomory_cuts = 0; + i_t num_mir_cuts = 0; + i_t num_knapsack_cuts = 0; + i_t num_cg_cuts = 0; + for (i_t i = 0; i < cut_types.size(); i++) { + if (cut_types[i] == cut_type_t::MIXED_INTEGER_GOMORY) { + num_gomory_cuts++; + } else if (cut_types[i] == cut_type_t::MIXED_INTEGER_ROUNDING) { + num_mir_cuts++; + } else if (cut_types[i] == cut_type_t::KNAPSACK) { + num_knapsack_cuts++; + } else if (cut_types[i] == cut_type_t::CHVATAL_GOMORY) { + num_cg_cuts++; + } + } + settings.log.printf("%s: Gomory cuts: %d, MIR cuts: %d, Knapsack cuts: %d CG cuts: %d\n", + prefix.c_str(), + num_gomory_cuts, + num_mir_cuts, + num_knapsack_cuts, + num_cg_cuts); +} + +template +f_t fractional_part(f_t a) { return a - std::floor(a); } + + +template +void read_saved_solution_for_cut_verification(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + std::vector& saved_solution); + +template +f_t minimum_violation(const csr_matrix_t& C, + const std::vector& cut_rhs, + const std::vector& x) +{ + // Check to see that this is a cut i.e C*x > d + std::vector Cx(C.m); + csc_matrix_t C_col(C.m, C.n, 0); + C.to_compressed_col(C_col); + matrix_vector_multiply(C_col, 1.0, x, 0.0, Cx); + f_t min_cut_violation = inf; + for (i_t k = 0; k < Cx.size(); k++) { + if (Cx[k] <= cut_rhs[k]) { + printf("C*x <= d for cut %d. C*x %e rhs %e\n", k, Cx[k], cut_rhs[k]); + exit(1); + } + min_cut_violation = std::min(min_cut_violation, Cx[k] - cut_rhs[k]); + } + return min_cut_violation; +} + +template +class cut_pool_t { + public: + cut_pool_t(i_t original_vars, const simplex_solver_settings_t& settings) + : original_vars_(original_vars), + settings_(settings), + cut_storage_(0, original_vars, 0), + rhs_storage_(0), + cut_age_(0), + cut_type_(0), + scored_cuts_(0) + { + } + + // Add a cut in the form: cut'*x >= rhs. + // We expect that the cut is violated by the current relaxation xstar + // cut'*xstart < rhs + void add_cut(cut_type_t cut_type, const sparse_vector_t& cut, f_t rhs); + + void score_cuts(std::vector& x_relax); + + // We return the cuts in the form best_cuts*x <= best_rhs + i_t get_best_cuts(csr_matrix_t& best_cuts, std::vector& best_rhs, std::vector& best_cut_types); + + void age_cuts(); + + void drop_cuts(); + + i_t pool_size() const { return cut_storage_.m; } + + void print_cutpool_types() { print_cut_types("In cut pool", cut_type_, settings_); } + + private: + f_t cut_distance(i_t row, const std::vector& x, f_t& cut_violation, f_t &cut_norm); + f_t cut_density(i_t row); + f_t cut_orthogonality(i_t i, i_t j); + + i_t original_vars_; + const simplex_solver_settings_t& settings_; + + csr_matrix_t cut_storage_; + std::vector rhs_storage_; + std::vector cut_age_; + std::vector cut_type_; + + i_t scored_cuts_; + std::vector cut_distances_; + std::vector cut_norms_; + std::vector cut_orthogonality_; + std::vector cut_scores_; + std::vector best_cuts_; +}; + +template +class knapsack_generation_t { + public: + knapsack_generation_t(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types); + + i_t generate_knapsack_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar, + i_t knapsack_row, + sparse_vector_t& cut, + f_t& cut_rhs); + + i_t num_knapsack_constraints() const { return knapsack_constraints_.size(); } + const std::vector& get_knapsack_constraints() const { return knapsack_constraints_; } + + private: + // Generate a heuristic solution to the 0-1 knapsack problem + f_t greedy_knapsack_problem(const std::vector& values, + const std::vector& weights, + f_t rhs, + std::vector& solution); + + // Solve a 0-1 knapsack problem using dynamic programming + f_t solve_knapsack_problem(const std::vector& values, + const std::vector& weights, + f_t rhs, + std::vector& solution); + + std::vector is_slack_; + std::vector knapsack_constraints_; +}; + +// Forward declaration +template +class mixed_integer_rounding_cut_t; + +template +class cut_generation_t { + public: + cut_generation_t(cut_pool_t& cut_pool, + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types) + : cut_pool_(cut_pool), knapsack_generation_(lp, settings, Arow, new_slacks, var_types) + { + } + + void generate_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list); + private: + + // Generate all mixed integer gomory cuts + void generate_gomory_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list); + + // Generate all mixed integer rounding cuts + void generate_mir_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar); + + // Generate all knapsack cuts + void generate_knapsack_cuts(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& new_slacks, + const std::vector& var_types, + const std::vector& xstar); + + cut_pool_t& cut_pool_; + knapsack_generation_t knapsack_generation_; +}; + +template +class tableau_equality_t { + public: + tableau_equality_t(const lp_problem_t& lp, + basis_update_mpf_t& basis_update, + const std::vector nonbasic_list) + : b_bar_(lp.num_rows, 0.0), + nonbasic_mark_(lp.num_cols, 0), + x_workspace_(lp.num_cols, 0.0), + x_mark_(lp.num_cols, 0) + { + basis_update.b_solve(lp.rhs, b_bar_); + for (i_t j : nonbasic_list) { + nonbasic_mark_[j] = 1; + } + } + + // Generates the base inequalities: C*x == d that will be turned into cuts + i_t generate_base_equality(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + const std::vector& var_types, + basis_update_mpf_t& basis_update, + const std::vector& xstar, + const std::vector& basic_list, + const std::vector& nonbasic_list, + i_t i, + sparse_vector_t& inequality, + f_t& inequality_rhs); + + private: + std::vector b_bar_; + std::vector nonbasic_mark_; + std::vector x_workspace_; + std::vector x_mark_; +}; + +template +class mixed_integer_rounding_cut_t { + public: + mixed_integer_rounding_cut_t(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& new_slacks, + const std::vector& xstar); + + // Convert an inequality of the form: sum_j a_j x_j >= beta + // with l_j <= x_j <= u_j into the form: + // sum_{j not in L union U} d_j x_j + sum_{j in L} d_j v_j + // + sum_{j in U} d_j w_j >= delta, + // where v_j = x_j - l_j for j in L + // and w_j = u_j - x_j for j in Us + void to_nonnegative(const lp_problem_t& lp, + sparse_vector_t& inequality, + f_t& rhs); + + void relaxation_to_nonnegative(const lp_problem_t& lp, + const std::vector& xstar, + std::vector& xstar_nonnegative); + + // Convert an inequality of the form: + // sum_{j not in L union U} d_j x_j + sum_{j in L} d_j v_j + // + sum_{j in U} d_j w_j >= delta + // where v_j = x_j - l_j for j in L + // and w_j = u_j - x_j for j in U + // back to an inequality on the original variables + // sum_j a_j x_j >= beta + void to_original(const lp_problem_t&lp, + sparse_vector_t& inequality, + f_t& rhs); + + // Given a cut of the form sum_j d_j x_j >= beta + // with l_j <= x_j <= u_j, try to remove coefficients d_j + // with | d_j | < epsilon + void remove_small_coefficients(const std::vector& lower_bounds, + const std::vector& upper_bounds, + sparse_vector_t& cut, + f_t& cut_rhs); + + + // Given an inequality sum_j a_j x_j >= beta, x_j >= 0, x_j in Z, j in I + // generate an MIR cut of the form sum_j d_j x_j >= delta + i_t generate_cut_nonnegative(const sparse_vector_t& a, + f_t beta, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs); + + f_t compute_violation(const sparse_vector_t& cut, + f_t cut_rhs, + const std::vector& xstar); + + i_t generate_cut(const sparse_vector_t& a, + f_t beta, + const std::vector& upper_bounds, + const std::vector& lower_bounds, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs); + + void substitute_slacks(const lp_problem_t& lp, + csr_matrix_t& Arow, + sparse_vector_t& cut, + f_t& cut_rhs); + + // Combine the pivot row with the inequality to eliminate the variable j + // The new inequality is returned in inequality and inequality_rhs + void combine_rows(const lp_problem_t& lp, + csr_matrix_t& Arow, + i_t j, + const sparse_vector_t& pivot_row, + f_t pivot_row_rhs, + sparse_vector_t& inequality, + f_t& inequality_rhs); + + private: + i_t num_vars_; + const simplex_solver_settings_t& settings_; + std::vector x_workspace_; + std::vector x_mark_; + std::vector has_lower_; + std::vector has_upper_; + std::vector is_slack_; + std::vector slack_rows_; + std::vector indices_; + std::vector bound_info_; + bool needs_complement_; +}; + +template +class strong_cg_cut_t { + public: + strong_cg_cut_t(const lp_problem_t& lp, + const std::vector& var_types, + const std::vector& xstar); + + i_t generate_strong_cg_cut(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const sparse_vector_t& inequality, + const f_t inequality_rhs, + const std::vector& xstar, + sparse_vector_t& cut, + f_t& cut_rhs); + + i_t remove_continuous_variables_integers_nonnegative( + const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + sparse_vector_t& inequality, + f_t& inequality_rhs); + + void to_original_integer_variables(const lp_problem_t& lp, + sparse_vector_t& cut, + f_t& cut_rhs); + + i_t generate_strong_cg_cut_integer_only(const simplex_solver_settings_t& settings, + const std::vector& var_types, + const sparse_vector_t& inequality, + f_t inequality_rhs, + sparse_vector_t& cut, + f_t& cut_rhs); + + private: + + i_t generate_strong_cg_cut_helper(const std::vector& indicies, + const std::vector& coefficients, + f_t rhs, + const std::vector& var_types, + sparse_vector_t& cut, + f_t& cut_rhs); + + std::vector transformed_variables_; +}; + +template +i_t add_cuts(const simplex_solver_settings_t& settings, + const csr_matrix_t& cuts, + const std::vector& cut_rhs, + lp_problem_t& lp, + std::vector& new_slacks, + lp_solution_t& solution, + basis_update_mpf_t& basis_update, + std::vector& basic_list, + std::vector& nonbasic_list, + std::vector& vstatus, + std::vector& edge_norms); + +template +void remove_cuts(lp_problem_t& lp, + const simplex_solver_settings_t& settings, + csr_matrix_t& Arow, + std::vector& new_slacks, + i_t original_rows, + std::vector& var_types, + std::vector& vstatus, + std::vector& x, + std::vector& y, + std::vector& z, + std::vector& basic_list, + std::vector& nonbasic_list, + basis_update_mpf_t& basis_update); + +} + diff --git a/cpp/src/dual_simplex/dense_matrix.hpp b/cpp/src/dual_simplex/dense_matrix.hpp index b1fc521b3..3f5287113 100644 --- a/cpp/src/dual_simplex/dense_matrix.hpp +++ b/cpp/src/dual_simplex/dense_matrix.hpp @@ -18,6 +18,8 @@ class dense_matrix_t { public: dense_matrix_t(i_t rows, i_t cols) : m(rows), n(cols), values(rows * cols, 0.0) {} + dense_matrix_t(i_t rows, i_t cols, f_t value) : m(rows), n(cols), values(rows * cols, value) {} + void resize(i_t rows, i_t cols) { m = rows; diff --git a/cpp/src/dual_simplex/mip_node.hpp b/cpp/src/dual_simplex/mip_node.hpp index de147132a..5ee4f49d1 100644 --- a/cpp/src/dual_simplex/mip_node.hpp +++ b/cpp/src/dual_simplex/mip_node.hpp @@ -60,6 +60,7 @@ class mip_node_t { node_id(0), branch_var(-1), branch_dir(rounding_direction_t::NONE), + integer_infeasible(-1), objective_estimate(std::numeric_limits::infinity()), vstatus(basis) { @@ -73,6 +74,7 @@ class mip_node_t { i_t branch_variable, rounding_direction_t branch_direction, f_t branch_var_value, + i_t integer_inf, const std::vector& basis) : status(node_status_t::PENDING), lower_bound(parent_node->lower_bound), @@ -82,9 +84,9 @@ class mip_node_t { branch_var(branch_variable), branch_dir(branch_direction), fractional_val(branch_var_value), + integer_infeasible(integer_inf), objective_estimate(parent_node->objective_estimate), vstatus(basis) - { branch_var_lower = branch_direction == rounding_direction_t::DOWN ? problem.lower[branch_var] : std::ceil(branch_var_value); @@ -250,6 +252,7 @@ class mip_node_t { f_t branch_var_lower; f_t branch_var_upper; f_t fractional_val; + i_t integer_infeasible; mip_node_t* parent; std::unique_ptr children[2]; @@ -285,6 +288,7 @@ class search_tree_t { void branch(mip_node_t* parent_node, const i_t branch_var, const f_t fractional_val, + const i_t integer_infeasible, const std::vector& parent_vstatus, const lp_problem_t& original_lp, logger_t& log) @@ -297,8 +301,8 @@ class search_tree_t { branch_var, rounding_direction_t::DOWN, fractional_val, + integer_infeasible, parent_vstatus); - graphviz_edge(log, parent_node, down_child.get(), @@ -312,6 +316,7 @@ class search_tree_t { branch_var, rounding_direction_t::UP, fractional_val, + integer_infeasible, parent_vstatus); graphviz_edge(log, diff --git a/cpp/src/dual_simplex/phase2.cpp b/cpp/src/dual_simplex/phase2.cpp index 2bc00f636..08496ca42 100644 --- a/cpp/src/dual_simplex/phase2.cpp +++ b/cpp/src/dual_simplex/phase2.cpp @@ -1231,8 +1231,14 @@ i_t initialize_steepest_edge_norms(const lp_problem_t& lp, last_log = tic(); settings.log.printf("Initialized %d of %d steepest edge norms in %.2fs\n", k, m, now); } - if (toc(start_time) > settings.time_limit) { return -1; } - if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { return -1; } + if (toc(start_time) > settings.time_limit) { + printf("initialize_steepest_edge time limit\n"); + return -1; + } + if (settings.concurrent_halt != nullptr && *settings.concurrent_halt == 1) { + printf("initialize_steepest_edge concurrent_halt\n"); + return -2; + } } return 0; } @@ -1733,6 +1739,74 @@ f_t dual_infeasibility(const lp_problem_t& lp, return sum_infeasible; } + +template +f_t primal_infeasibility_breakdown(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& vstatus, + const std::vector& x, + f_t& basic_infeas, + f_t& nonbasic_infeas, + f_t& basic_over) +{ + const i_t n = lp.num_cols; + f_t primal_inf = 0; + basic_infeas = 0.0; + basic_over = 0.0; + nonbasic_infeas = 0.0; + for (i_t j = 0; j < n; ++j) { + if (x[j] < lp.lower[j]) { + // x_j < l_j => -x_j > -l_j => -x_j + l_j > 0 + const f_t infeas = -x[j] + lp.lower[j]; + if (vstatus[j] == variable_status_t::BASIC) { + basic_infeas += infeas; + if (infeas > settings.primal_tol) { + basic_over += infeas; + } + } else { + nonbasic_infeas += infeas; + } + primal_inf += infeas; +#ifdef PRIMAL_INFEASIBLE_DEBUG + if (infeas > settings.primal_tol) { + settings.log.printf("x %d infeas %e lo %e val %e up %e vstatus %d\n", + j, + infeas, + lp.lower[j], + x[j], + lp.upper[j], + static_cast(vstatus[j])); + } +#endif + } + if (x[j] > lp.upper[j]) { + // x_j > u_j => x_j - u_j > 0 + const f_t infeas = x[j] - lp.upper[j]; + if (vstatus[j] == variable_status_t::BASIC) { + basic_infeas += infeas; + if (infeas > settings.primal_tol) { + basic_over += infeas; + } + } else { + nonbasic_infeas += infeas; + } + primal_inf += infeas; +#ifdef PRIMAL_INFEASIBLE_DEBUG + if (infeas > settings.primal_tol) { + settings.log.printf("x %d infeas %e lo %e val %e up %e vstatus %d\n", + j, + infeas, + lp.lower[j], + x[j], + lp.upper[j], + static_cast(vstatus[j])); + } +#endif + } + } + return primal_inf; +} + template f_t primal_infeasibility(const lp_problem_t& lp, const simplex_solver_settings_t& settings, @@ -2018,7 +2092,9 @@ f_t amount_of_perturbation(const lp_problem_t& lp, const std::vector -void prepare_optimality(const lp_problem_t& lp, +void prepare_optimality(i_t info, + f_t orig_primal_infeas, + const lp_problem_t& lp, const simplex_solver_settings_t& settings, basis_update_mpf_t& ft, const std::vector& objective, @@ -2040,6 +2116,7 @@ void prepare_optimality(const lp_problem_t& lp, sol.objective = compute_objective(lp, sol.x); sol.user_objective = compute_user_objective(lp, sol.objective); f_t perturbation = phase2::amount_of_perturbation(lp, objective); + f_t orig_perturbation = perturbation; if (perturbation > 1e-6 && phase == 2) { // Try to remove perturbation std::vector unperturbed_y(m); @@ -2085,6 +2162,23 @@ void prepare_optimality(const lp_problem_t& lp, settings.log.printf("\n"); } } + + if (primal_infeas > 10.0*settings.primal_tol) + { + f_t basic_infeas = 0.0; + f_t nonbasic_infeas = 0.0; + f_t basic_over = 0.0; + phase2::primal_infeasibility_breakdown(lp, settings, vstatus, x, basic_infeas, nonbasic_infeas, basic_over); + printf("Primal infeasibility %e/%e (Basic %e, Nonbasic %e, Basic over %e). Perturbation %e/%e. Info %d\n", + primal_infeas, + orig_primal_infeas, + basic_infeas, + nonbasic_infeas, + basic_over, + orig_perturbation, + perturbation, + info); + } } template @@ -2325,12 +2419,32 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, basic_list, nonbasic_list, delta_y_steepest_edge); } else { std::fill(delta_y_steepest_edge.begin(), delta_y_steepest_edge.end(), -1); - if (phase2::initialize_steepest_edge_norms( - lp, settings, start_time, basic_list, ft, delta_y_steepest_edge) == -1) { + i_t status = phase2::initialize_steepest_edge_norms( + lp, settings, start_time, basic_list, ft, delta_y_steepest_edge); + if (status == -2) { + return dual::status_t::CONCURRENT_LIMIT; + } + if (status == -1) { return dual::status_t::TIME_LIMIT; } } } else { + + // Check that none of the basic variables have a steepest edge that is nonpositive + for (i_t k = 0; k < m; k++) + { + const i_t j = basic_list[k]; + bool fix_needed = false; + if (delta_y_steepest_edge[j] <= 0.0) + { + fix_needed = true; + //printf("Basic variable %d has a nonpositive steepest edge %e\n", j, delta_y_steepest_edge[j]); + delta_y_steepest_edge[j] = 1e-4; + } + if (fix_needed) { + //printf("Basic variable had nonpositive steepest edge\n"); + } + } settings.log.printf("using exisiting steepest edge %e\n", vector_norm2(delta_y_steepest_edge)); } @@ -2411,7 +2525,60 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, } timers.pricing_time += timers.stop_timer(); if (leaving_index == -1) { - phase2::prepare_optimality(lp, + + +#ifdef CHECK_BASIS_UPDATE + for (i_t k = 0; k < basic_list.size(); k++) { + const i_t jj = basic_list[k]; + sparse_vector_t ei_sparse(m, 1); + ei_sparse.i[0] = k; + ei_sparse.x[0] = 1.0; + sparse_vector_t ubar_sparse(m, 0); + ft.b_transpose_solve(ei_sparse, ubar_sparse); + std::vector ubar_dense(m); + ubar_sparse.to_dense(ubar_dense); + std::vector BTu_dense(m); + b_transpose_multiply(lp, basic_list, ubar_dense, BTu_dense); + for (i_t l = 0; l < m; l++) { + if (l != k) { + settings.log.printf("BTu_dense[%d] = %e i %d\n", l, BTu_dense[l], k); + } else { + settings.log.printf("BTu_dense[%d] = %e != 1.0 i %d\n", l, BTu_dense[l], k); + } + } + for (i_t h = 0; h < m; h++) { + settings.log.printf("i %d ubar_dense[%d] = %.16e\n", k, h, ubar_dense[h]); + } + } + settings.log.printf("ft.num_updates() %d\n", ft.num_updates()); + for (i_t h = 0; h < m; h++) { + settings.log.printf("basic_list[%d] = %d\n", h, basic_list[h]); + } + +#endif + + primal_infeasibility_squared = phase2::compute_initial_primal_infeasibilities( + lp, settings, basic_list, x, squared_infeasibilities, infeasibility_indices, primal_infeasibility); + if (primal_infeasibility > settings.primal_tol) { + + const i_t nz = infeasibility_indices.size(); + for (i_t k = 0; k < nz; ++k) { + const i_t j = infeasibility_indices[k]; + const f_t squared_infeas = squared_infeasibilities[j]; + const f_t val = squared_infeas / delta_y_steepest_edge[j]; + if (squared_infeas >= 0.0 && delta_y_steepest_edge[j] < 0.0) { + printf("Iter %d potential leaving %d val %e squared infeas %e delta_y_steepest_edge %e\n", iter, j, val, squared_infeas, delta_y_steepest_edge[j]); + //delta_y_steepest_edge[j] = 1e-4; + } + } + + //printf("No leaving variable. Updated primal infeasibility: %e\n", primal_infeasibility); + //continue; + } + + phase2::prepare_optimality(0, + primal_infeasibility, + lp, settings, ft, objective, @@ -2583,7 +2750,9 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, // Need to reset the objective value, since we have recomputed x obj = phase2::compute_perturbed_objective(objective, x); if (dual_infeas <= settings.dual_tol && primal_infeasibility <= settings.primal_tol) { - phase2::prepare_optimality(lp, + phase2::prepare_optimality(1, + primal_infeasibility, + lp, settings, ft, objective, @@ -2626,7 +2795,9 @@ dual::status_t dual_phase2_with_advanced_basis(i_t phase, if (primal_infeasibility <= settings.primal_tol && orig_dual_infeas <= settings.dual_tol) { - phase2::prepare_optimality(lp, + phase2::prepare_optimality(2, + primal_infeasibility, + lp, settings, ft, objective, diff --git a/cpp/src/dual_simplex/pseudo_costs.cpp b/cpp/src/dual_simplex/pseudo_costs.cpp index 0a8f660e9..cb9b81af0 100644 --- a/cpp/src/dual_simplex/pseudo_costs.cpp +++ b/cpp/src/dual_simplex/pseudo_costs.cpp @@ -133,6 +133,39 @@ void strong_branch_helper(i_t start, } } +template +f_t trial_branching(const lp_problem_t& original_lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const std::vector& root_vstatus, + const std::vector& edge_norms, + i_t branch_var, + f_t branch_var_lower, + f_t branch_var_upper, + i_t& iter) +{ + lp_problem_t child_problem = original_lp; + child_problem.lower[branch_var] = branch_var_lower; + child_problem.upper[branch_var] = branch_var_upper; + + simplex_solver_settings_t child_settings = settings; + child_settings.set_log(false); + f_t lp_start_time = tic(); + child_settings.iteration_limit = 200; + lp_solution_t solution(original_lp.num_rows, original_lp.num_cols); + std::vector vstatus = root_vstatus; + std::vector child_edge_norms = edge_norms; + dual::status_t status = dual_phase2( + 2, 0, lp_start_time, child_problem, child_settings, vstatus, solution, iter, child_edge_norms); + //printf("Trial branching on variable %d. Lo: %e Up: %e. Iter %d. Status %d. Obj %e\n", branch_var, child_problem.lower[branch_var], child_problem.upper[branch_var], iter, status, compute_objective(child_problem, solution.x)); + + if (status == dual::status_t::OPTIMAL || status == dual::status_t::ITERATION_LIMIT || status == dual::status_t::CUTOFF) { + return compute_objective(child_problem, solution.x); + } else { + return std::numeric_limits::quiet_NaN(); + } +} + } // namespace template @@ -314,6 +347,120 @@ i_t pseudo_costs_t::variable_selection(const std::vector& fractio return branch_var; } +template +i_t pseudo_costs_t::reliable_variable_selection(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const std::vector& vstatus, + const std::vector& edge_norms, + const std::vector& fractional, + const std::vector& solution, + f_t current_obj, + logger_t& log) +{ + mutex.lock(); + + const i_t num_fractional = fractional.size(); + std::vector pseudo_cost_up(num_fractional); + std::vector pseudo_cost_down(num_fractional); + std::vector score(num_fractional); + + i_t num_initialized_down; + i_t num_initialized_up; + f_t pseudo_cost_down_avg; + f_t pseudo_cost_up_avg; + + i_t iter = 0; + i_t trial_branches = 0; + + initialized(num_initialized_down, num_initialized_up, pseudo_cost_down_avg, pseudo_cost_up_avg); + + mutex.unlock(); + + log.printf("PC: num initialized down %d up %d avg down %e up %e\n", + num_initialized_down, + num_initialized_up, + pseudo_cost_down_avg, + pseudo_cost_up_avg); + + + const i_t reliable_threshold = 1; + + for (i_t k = 0; k < num_fractional; k++) { + const i_t j = fractional[k]; + mutex.lock(); + bool down_reliable = pseudo_cost_num_down[j] >= reliable_threshold; + mutex.unlock(); + if (down_reliable) { + mutex.lock(); + pseudo_cost_down[k] = pseudo_cost_sum_down[j] / pseudo_cost_num_down[j]; + mutex.unlock(); + } else { + // Do trial branching on the down branch + i_t trial_iter = 0; + f_t obj = trial_branching(lp, settings, var_types, vstatus, edge_norms, j, lp.lower[j], std::floor(solution[j]), trial_iter); + trial_branches++; + iter += trial_iter; + if (!std::isnan(obj)) { + f_t change_in_obj = obj - current_obj; + f_t change_in_x = solution[j] - std::floor(solution[j]); + mutex.lock(); + pseudo_cost_sum_down[j] += change_in_obj / change_in_x; + pseudo_cost_num_down[j]++; + mutex.unlock(); + pseudo_cost_down[k] = pseudo_cost_sum_down[j] / pseudo_cost_num_down[j]; + } + } + + mutex.lock(); + bool up_reliable = pseudo_cost_num_up[j] >= reliable_threshold; + mutex.unlock(); + if (up_reliable) { + mutex.lock(); + pseudo_cost_up[k] = pseudo_cost_sum_up[j] / pseudo_cost_num_up[j]; + mutex.unlock(); + } else { + // Do trial branching on the up branch + i_t trial_iter = 0; + f_t obj = trial_branching(lp, settings, var_types, vstatus, edge_norms, j, std::ceil(solution[j]), lp.upper[j], trial_iter); + trial_branches++; + iter += trial_iter; + if (!std::isnan(obj)) { + f_t change_in_obj = obj - current_obj; + f_t change_in_x = std::ceil(solution[j]) - solution[j]; + mutex.lock(); + pseudo_cost_sum_up[j] += change_in_obj / change_in_x; + pseudo_cost_num_up[j]++; + pseudo_cost_up[k] = pseudo_cost_sum_up[j] / pseudo_cost_num_up[j]; + mutex.unlock(); + } + } + constexpr f_t eps = 1e-6; + const f_t f_down = solution[j] - std::floor(solution[j]); + const f_t f_up = std::ceil(solution[j]) - solution[j]; + score[k] = + std::max(f_down * pseudo_cost_down[k], eps) * std::max(f_up * pseudo_cost_up[k], eps); + } + + i_t branch_var = fractional[0]; + f_t max_score = -1; + i_t select = -1; + for (i_t k = 0; k < num_fractional; k++) { + if (score[k] > max_score) { + max_score = score[k]; + branch_var = fractional[k]; + select = k; + } + } + + printf( + "pc reliability branching on %d. Value %e. Score %e. Iter %d. Trial branches %d\n", branch_var, solution[branch_var], score[select], iter, trial_branches); + + + return branch_var; +} + + template f_t pseudo_costs_t::obj_estimate(const std::vector& fractional, const std::vector& solution, diff --git a/cpp/src/dual_simplex/pseudo_costs.hpp b/cpp/src/dual_simplex/pseudo_costs.hpp index 4bab438fa..750230fa4 100644 --- a/cpp/src/dual_simplex/pseudo_costs.hpp +++ b/cpp/src/dual_simplex/pseudo_costs.hpp @@ -52,6 +52,16 @@ class pseudo_costs_t { const std::vector& solution, logger_t& log); + i_t reliable_variable_selection(const lp_problem_t& lp, + const simplex_solver_settings_t& settings, + const std::vector& var_types, + const std::vector& vstatus, + const std::vector& edge_norms, + const std::vector& fractional, + const std::vector& solution, + f_t current_obj, + logger_t& log); + void update_pseudo_costs_from_strong_branching(const std::vector& fractional, const std::vector& root_soln); std::vector pseudo_cost_sum_up; diff --git a/cpp/src/dual_simplex/simplex_solver_settings.hpp b/cpp/src/dual_simplex/simplex_solver_settings.hpp index d86f84c39..61fb79d9a 100644 --- a/cpp/src/dual_simplex/simplex_solver_settings.hpp +++ b/cpp/src/dual_simplex/simplex_solver_settings.hpp @@ -87,9 +87,16 @@ struct simplex_solver_settings_t { iteration_log_frequency(1000), first_iteration_log(2), num_threads(omp_get_max_threads() - 1), + max_cut_passes(0), + mir_cuts(-1), + mixed_integer_gomory_cuts(-1), + knapsack_cuts(-1), + strong_chvatal_gomory_cuts(-1), num_bfs_workers(std::max(num_threads / 4, 1)), random_seed(0), inside_mip(0), + sub_mip(0), + reliability_branching(-1), solution_callback(nullptr), heuristic_preemption_callback(nullptr), concurrent_halt(nullptr) @@ -154,11 +161,18 @@ struct simplex_solver_settings_t { i_t first_iteration_log; // number of iterations to log at beginning of solve i_t num_threads; // number of threads to use i_t random_seed; // random seed + i_t max_cut_passes; // number of cut passes to make + i_t mir_cuts; // -1 automatic, 0 to disable, >0 to enable MIR cuts + i_t mixed_integer_gomory_cuts; // -1 automatic, 0 to disable, >0 to enable mixed integer Gomory cuts + i_t knapsack_cuts; // -1 automatic, 0 to disable, >0 to enable knapsack cuts + i_t strong_chvatal_gomory_cuts; // -1 automatic, 0 to disable, >0 to enable strong Chvatal Gomory cuts i_t num_bfs_workers; // number of threads dedicated to the best-first search diving_heuristics_settings_t diving_settings; // Settings for the diving heuristics i_t inside_mip; // 0 if outside MIP, 1 if inside MIP at root node, 2 if inside MIP at leaf node + i_t sub_mip; // 0 if in regular MIP solve, 1 if in sub-MIP solve + i_t reliability_branching; // -1 automatic, 0 to disable, >0 to enable reliability branching std::function&, f_t)> solution_callback; std::function&, f_t)> node_processed_callback; std::function heuristic_preemption_callback; diff --git a/cpp/src/dual_simplex/solution.hpp b/cpp/src/dual_simplex/solution.hpp index d1d745cbd..d882e21e2 100644 --- a/cpp/src/dual_simplex/solution.hpp +++ b/cpp/src/dual_simplex/solution.hpp @@ -39,7 +39,7 @@ class lp_solution_t { std::vector x; // Dual solution vector. Lagrange multipliers for equality constraints. std::vector y; - // Dual solution vector. Lagrange multipliers for inequality constraints. + // Reduced costs std::vector z; f_t objective; f_t user_objective; diff --git a/cpp/src/dual_simplex/solve.cpp b/cpp/src/dual_simplex/solve.cpp index 1f31a757d..2e01f1102 100644 --- a/cpp/src/dual_simplex/solve.cpp +++ b/cpp/src/dual_simplex/solve.cpp @@ -8,6 +8,7 @@ #include #include +#include #include #include #include @@ -597,7 +598,7 @@ i_t solve(const user_problem_t& problem, { i_t status; if (is_mip(problem) && !settings.relaxation) { - branch_and_bound_t branch_and_bound(problem, settings); + branch_and_bound_t branch_and_bound(problem, settings, tic()); mip_solution_t mip_solution(problem.num_cols); mip_status_t mip_status = branch_and_bound.solve(mip_solution); if (mip_status == mip_status_t::OPTIMAL) { @@ -636,7 +637,7 @@ i_t solve_mip_with_guess(const user_problem_t& problem, { i_t status; if (is_mip(problem)) { - branch_and_bound_t branch_and_bound(problem, settings); + branch_and_bound_t branch_and_bound(problem, settings, tic()); branch_and_bound.set_initial_guess(guess); mip_status_t mip_status = branch_and_bound.solve(solution); if (mip_status == mip_status_t::OPTIMAL) { diff --git a/cpp/src/dual_simplex/sparse_matrix.cpp b/cpp/src/dual_simplex/sparse_matrix.cpp index 7edc7b1eb..f717fc352 100644 --- a/cpp/src/dual_simplex/sparse_matrix.cpp +++ b/cpp/src/dual_simplex/sparse_matrix.cpp @@ -363,6 +363,75 @@ i_t csc_matrix_t::remove_row(i_t row) return 0; } +template +i_t csr_matrix_t::append_rows(const csr_matrix_t& C) +{ + const i_t old_m = this->m; + const i_t n = this->n; + const i_t old_nz = this->row_start[old_m]; + const i_t C_row = C.m; + if (C.n > n) { + printf("append_rows error: C.n %d n %d\n", C.n, n); + return -1; + } + const i_t C_nz = C.row_start[C_row]; + const i_t new_nz = old_nz + C_nz; + const i_t new_m = old_m + C_row; + + this->j.resize(new_nz); + this->x.resize(new_nz); + this->row_start.resize(new_m + 1); + + i_t nz = old_nz; + for (i_t i = old_m; i < new_m; i++) { + const i_t k = i - old_m; + const i_t nz_row = C.row_start[k + 1] - C.row_start[k]; + this->row_start[i] = nz; + nz += nz_row; + } + this->row_start[new_m] = nz; + + for (i_t p = old_nz; p < new_nz; p++) { + const i_t q = p - old_nz; + this->j[p] = C.j[q]; + } + + for (i_t p = old_nz; p < new_nz; p++) { + const i_t q = p - old_nz; + this->x[p] = C.x[q]; + } + + this->m = new_m; + this->nz_max = new_nz; + return 0; +} + +template +i_t csr_matrix_t::append_row(const sparse_vector_t& c) +{ + const i_t old_m = this->m; + const i_t old_nz = this->row_start[old_m]; + const i_t c_nz = c.i.size(); + const i_t new_nz = old_nz + c_nz; + const i_t new_m = old_m + 1; + + this->j.resize(new_nz); + this->x.resize(new_nz); + this->row_start.resize(new_m + 1); + this->row_start[new_m] = new_nz; + + i_t nz = old_nz; + for (i_t k = 0; k < c_nz; k++) { + this->j[nz] = c.i[k]; + this->x[nz] = c.x[k]; + nz++; + } + + this->m = new_m; + this->nz_max = new_nz; + return 0; +} + template void csc_matrix_t::print_matrix(FILE* fid) const { @@ -505,6 +574,10 @@ i_t csc_matrix_t::check_matrix(std::string matrix_name) const #ifdef CHECK_MATRIX std::vector row_marker(this->m, -1); for (i_t j = 0; j < this->n; ++j) { + if (j >= col_start.size()) { + printf("Col start too small size %ld n %d\n", col_start.size(), this->n); + return -1; + } const i_t col_start = this->col_start[j]; const i_t col_end = this->col_start[j + 1]; if (col_start > col_end || col_start > this->col_start[this->n]) { @@ -559,7 +632,7 @@ size_t csc_matrix_t::hash() const } template -void csr_matrix_t::check_matrix(std::string matrix_name) const +i_t csr_matrix_t::check_matrix(std::string matrix_name) const { std::vector col_marker(this->n, -1); for (i_t i = 0; i < this->m; ++i) { @@ -567,12 +640,15 @@ void csr_matrix_t::check_matrix(std::string matrix_name) const const i_t row_end = this->row_start[i + 1]; for (i_t p = row_start; p < row_end; ++p) { const i_t j = this->j[p]; + if (j < 0 || j >= this->n) { printf("CSR Error: column index %d not in range [0, %d)\n", j, this->n); return -1;} if (col_marker[j] == i) { printf("CSR Error (%s) : repeated column index %d in row %d\n", matrix_name.c_str(), j, i); + return -1; } col_marker[j] = i; } } + return 0; } // x <- x + alpha * A(:, j) diff --git a/cpp/src/dual_simplex/sparse_matrix.hpp b/cpp/src/dual_simplex/sparse_matrix.hpp index 9ae8ea80b..ccf69dbe6 100644 --- a/cpp/src/dual_simplex/sparse_matrix.hpp +++ b/cpp/src/dual_simplex/sparse_matrix.hpp @@ -151,8 +151,14 @@ class csr_matrix_t { // Create a new matrix with the marked rows removed i_t remove_rows(std::vector& row_marker, csr_matrix_t& Aout) const; + // Append rows from another CSR matrix + i_t append_rows(const csr_matrix_t& C); + + // Append a row from a sparse vector + i_t append_row(const sparse_vector_t& c); + // Ensures no repeated column indices within a row - void check_matrix(std::string matrix_name = "") const; + i_t check_matrix(std::string matrix_name = "") const; bool is_diagonal() const { diff --git a/cpp/src/dual_simplex/sparse_vector.cpp b/cpp/src/dual_simplex/sparse_vector.cpp index 2d4745650..a8bd06afa 100644 --- a/cpp/src/dual_simplex/sparse_vector.cpp +++ b/cpp/src/dual_simplex/sparse_vector.cpp @@ -28,6 +28,21 @@ sparse_vector_t::sparse_vector_t(const csc_matrix_t& A, i_t } } +template +sparse_vector_t::sparse_vector_t(const csr_matrix_t& A, i_t row) +{ + const i_t row_start = A.row_start[row]; + const i_t row_end = A.row_start[row + 1]; + const i_t nz = row_end - row_start; + n = A.n; + i.reserve(nz); + x.reserve(nz); + for (i_t k = row_start; k < row_end; ++k) { + i.push_back(A.j[k]); + x.push_back(A.x[k]); + } +} + template void sparse_vector_t::from_dense(const std::vector& in) { @@ -106,6 +121,17 @@ void sparse_vector_t::inverse_permute_vector(const std::vector& p y.i = i_perm; } +template +f_t sparse_vector_t::dot(const std::vector& x_dense) const +{ + const i_t nz = i.size(); + f_t dot = 0.0; + for (i_t k = 0; k < nz; ++k) { + dot += x[k] * x_dense[i[k]]; + } + return dot; +} + template f_t sparse_vector_t::sparse_dot(const csc_matrix_t& Y, i_t y_col) const { @@ -207,6 +233,30 @@ f_t sparse_vector_t::find_coefficient(i_t index) const return std::numeric_limits::quiet_NaN(); } +template +void sparse_vector_t::squeeze(sparse_vector_t& y) const +{ + y.n = n; + + i_t nz = 0; + const i_t n = x.size(); + for (i_t k = 0; k < n; k++) { + if (x[k] != 0.0) { + nz++; + } + } + y.i.reserve(nz); + y.x.reserve(nz); + y.i.clear(); + y.x.clear(); + for (i_t k = 0; k < n; k++) { + if (x[k] != 0.0) { + y.i.push_back(i[k]); + y.x.push_back(x[k]); + } + } +} + #ifdef DUAL_SIMPLEX_INSTANTIATE_DOUBLE template class sparse_vector_t; #endif diff --git a/cpp/src/dual_simplex/sparse_vector.hpp b/cpp/src/dual_simplex/sparse_vector.hpp index 7acfdc8b5..c56ebf6d9 100644 --- a/cpp/src/dual_simplex/sparse_vector.hpp +++ b/cpp/src/dual_simplex/sparse_vector.hpp @@ -25,6 +25,8 @@ class sparse_vector_t { sparse_vector_t(const std::vector& in) { from_dense(in); } // Construct a sparse vector from a column of a CSC matrix sparse_vector_t(const csc_matrix_t& A, i_t col); + // Construct a sparse vector from a row of a CSR matrix + sparse_vector_t(const csr_matrix_t& A, i_t row); // gather a dense vector into a sparse vector void from_dense(const std::vector& in); // convert a sparse vector into a CSC matrix with a single column @@ -38,6 +40,8 @@ class sparse_vector_t { void inverse_permute_vector(const std::vector& p); // inverse permute a sparse vector into another sparse vector void inverse_permute_vector(const std::vector& p, sparse_vector_t& y) const; + // compute the dot product of a sparse vector with a dense vector + f_t dot(const std::vector& x) const; // compute the dot product of a sparse vector with a column of a CSC matrix f_t sparse_dot(const csc_matrix_t& Y, i_t y_col) const; // ensure the coefficients in the sparse vectory are sorted in terms of increasing index @@ -47,6 +51,8 @@ class sparse_vector_t { void negate(); f_t find_coefficient(i_t index) const; + void squeeze(sparse_vector_t& y) const; + i_t n; std::vector i; std::vector x; diff --git a/cpp/src/math_optimization/solver_settings.cu b/cpp/src/math_optimization/solver_settings.cu index 4e3dc6465..7126273be 100644 --- a/cpp/src/math_optimization/solver_settings.cu +++ b/cpp/src/math_optimization/solver_settings.cu @@ -87,6 +87,13 @@ solver_settings_t::solver_settings_t() : pdlp_settings(), mip_settings {CUOPT_DUALIZE, &pdlp_settings.dualize, -1, 1, -1}, {CUOPT_ORDERING, &pdlp_settings.ordering, -1, 1, -1}, {CUOPT_BARRIER_DUAL_INITIAL_POINT, &pdlp_settings.barrier_dual_initial_point, -1, 1, -1}, + {CUOPT_MIP_CUT_PASSES, &mip_settings.max_cut_passes, -1, std::numeric_limits::max(), 0}, + {CUOPT_MIP_NODE_LIMIT, &mip_settings.node_limit, 0, std::numeric_limits::max(), std::numeric_limits::max()}, + {CUOPT_MIP_RELIABILITY_BRANCHING, &mip_settings.reliability_branching, -1, std::numeric_limits::max(), -1}, + {CUOPT_MIP_MIR_CUTS, &mip_settings.mir_cuts, -1, 1, -1}, + {CUOPT_MIP_MIXED_INTEGER_GOMORY_CUTS, &mip_settings.mixed_integer_gomory_cuts, -1, 1, -1}, + {CUOPT_MIP_KNAPSACK_CUTS, &mip_settings.knapsack_cuts, -1, 1, -1}, + {CUOPT_MIP_STRONG_CHVATAL_GOMORY_CUTS, &mip_settings.strong_chvatal_gomory_cuts, -1, 1, -1}, {CUOPT_NUM_GPUS, &pdlp_settings.num_gpus, 1, 2, 1}, {CUOPT_NUM_GPUS, &mip_settings.num_gpus, 1, 2, 1} }; diff --git a/cpp/src/mip/diversity/diversity_manager.cu b/cpp/src/mip/diversity/diversity_manager.cu index cfe9876de..74a2935e2 100644 --- a/cpp/src/mip/diversity/diversity_manager.cu +++ b/cpp/src/mip/diversity/diversity_manager.cu @@ -216,10 +216,11 @@ bool diversity_manager_t::run_presolve(f_t time_limit) lp_dual_optimal_solution.resize(problem_ptr->n_constraints, problem_ptr->handle_ptr->get_stream()); problem_ptr->handle_ptr->sync_stream(); - CUOPT_LOG_INFO("After trivial presolve: %d constraints, %d variables, objective offset %f.", + CUOPT_LOG_INFO("After cuOpt presolve: %d constraints, %d variables, objective offset %f.", problem_ptr->n_constraints, problem_ptr->n_variables, problem_ptr->presolve_data.objective_offset); + CUOPT_LOG_INFO("cuOpt presolve time: %.2f", stats.presolve_time); return true; } diff --git a/cpp/src/mip/diversity/lns/rins.cu b/cpp/src/mip/diversity/lns/rins.cu index 7456b59ed..c886dc156 100644 --- a/cpp/src/mip/diversity/lns/rins.cu +++ b/cpp/src/mip/diversity/lns/rins.cu @@ -22,6 +22,8 @@ #include #include +#include + namespace cuopt::linear_programming::detail { template rins_t::rins_t(mip_solver_context_t& context_, @@ -259,6 +261,8 @@ void rins_t::run_rins() branch_and_bound_settings.integer_tol = context.settings.tolerances.integrality_tolerance; branch_and_bound_settings.num_threads = 2; branch_and_bound_settings.num_bfs_workers = 1; + branch_and_bound_settings.max_cut_passes = 0; + branch_and_bound_settings.sub_mip = 1; // In the future, let RINS use all the diving heuristics. For now, // restricting to guided diving. @@ -273,7 +277,8 @@ void rins_t::run_rins() rins_solution_queue.push_back(solution); }; dual_simplex::branch_and_bound_t branch_and_bound(branch_and_bound_problem, - branch_and_bound_settings); + branch_and_bound_settings, + dual_simplex::tic()); branch_and_bound.set_initial_guess(cuopt::host_copy(fixed_assignment, rins_handle.get_stream())); branch_and_bound_status = branch_and_bound.solve(branch_and_bound_solution); diff --git a/cpp/src/mip/diversity/recombiners/sub_mip.cuh b/cpp/src/mip/diversity/recombiners/sub_mip.cuh index 82670437a..e252745b7 100644 --- a/cpp/src/mip/diversity/recombiners/sub_mip.cuh +++ b/cpp/src/mip/diversity/recombiners/sub_mip.cuh @@ -13,6 +13,7 @@ #include #include #include +#include namespace cuopt::linear_programming::detail { @@ -104,6 +105,8 @@ class sub_mip_recombiner_t : public recombiner_t { branch_and_bound_settings.integer_tol = context.settings.tolerances.integrality_tolerance; branch_and_bound_settings.num_threads = 2; branch_and_bound_settings.num_bfs_workers = 1; + branch_and_bound_settings.max_cut_passes = 0; + branch_and_bound_settings.sub_mip = 1; // In the future, let SubMIP use all the diving heuristics. For now, // restricting to guided diving. @@ -119,7 +122,8 @@ class sub_mip_recombiner_t : public recombiner_t { // disable B&B logs, so that it is not interfering with the main B&B thread branch_and_bound_settings.log.log = false; dual_simplex::branch_and_bound_t branch_and_bound(branch_and_bound_problem, - branch_and_bound_settings); + branch_and_bound_settings, + dual_simplex::tic()); branch_and_bound_status = branch_and_bound.solve(branch_and_bound_solution); if (solution_vector.size() > 0) { cuopt_assert(fixed_assignment.size() == branch_and_bound_solution.x.size(), diff --git a/cpp/src/mip/presolve/third_party_presolve.cpp b/cpp/src/mip/presolve/third_party_presolve.cpp index 3082d0d6d..cc5a9dd5b 100644 --- a/cpp/src/mip/presolve/third_party_presolve.cpp +++ b/cpp/src/mip/presolve/third_party_presolve.cpp @@ -409,7 +409,7 @@ std::optional> third_party_presolve_t presolver; set_presolve_methods(presolver, category, dual_postsolve); diff --git a/cpp/src/mip/solve.cu b/cpp/src/mip/solve.cu index e6a392d40..1790be33b 100644 --- a/cpp/src/mip/solve.cu +++ b/cpp/src/mip/solve.cu @@ -222,7 +222,7 @@ mip_solution_t solve_mip(optimization_problem_t& op_problem, CUOPT_LOG_INFO("%d implied integers", result->implied_integer_indices.size()); } if (problem.is_objective_integral()) { CUOPT_LOG_INFO("Objective function is integral"); } - CUOPT_LOG_INFO("Papilo presolve time: %f", presolve_time); + CUOPT_LOG_INFO("Papilo presolve time: %.2f", presolve_time); } if (settings.user_problem_file != "") { CUOPT_LOG_INFO("Writing user problem to file: %s", settings.user_problem_file.c_str()); diff --git a/cpp/src/mip/solver.cu b/cpp/src/mip/solver.cu index 08e1806b9..48989f26f 100644 --- a/cpp/src/mip/solver.cu +++ b/cpp/src/mip/solver.cu @@ -109,7 +109,8 @@ solution_t mip_solver_t::run_solver() diversity_manager_t dm(context); dm.timer = timer_; - bool presolve_success = dm.run_presolve(timer_.remaining_time()); + const bool run_presolve = context.settings.presolve; + bool presolve_success = run_presolve ? dm.run_presolve(timer_.remaining_time()) : true; if (!presolve_success) { CUOPT_LOG_INFO("Problem proven infeasible in presolve"); solution_t sol(*context.problem_ptr); @@ -117,7 +118,7 @@ solution_t mip_solver_t::run_solver() context.problem_ptr->post_process_solution(sol); return sol; } - if (context.problem_ptr->empty) { + if (run_presolve && context.problem_ptr->empty) { CUOPT_LOG_INFO("Problem full reduced in presolve"); solution_t sol(*context.problem_ptr); sol.set_problem_fully_reduced(); @@ -126,7 +127,7 @@ solution_t mip_solver_t::run_solver() } // if the problem was reduced to a LP: run concurrent LP - if (context.problem_ptr->n_integer_vars == 0) { + if (run_presolve && context.problem_ptr->n_integer_vars == 0) { CUOPT_LOG_INFO("Problem reduced to a LP, running concurrent LP"); pdlp_solver_settings_t settings{}; settings.time_limit = timer_.remaining_time(); @@ -162,11 +163,18 @@ solution_t mip_solver_t::run_solver() branch_and_bound_solution.resize(branch_and_bound_problem.num_cols); // Fill in the settings for branch and bound - branch_and_bound_settings.time_limit = timer_.remaining_time(); + branch_and_bound_settings.time_limit = timer_.get_time_limit(); + branch_and_bound_settings.node_limit = context.settings.node_limit; + branch_and_bound_settings.reliability_branching = context.settings.reliability_branching; branch_and_bound_settings.print_presolve_stats = false; branch_and_bound_settings.absolute_mip_gap_tol = context.settings.tolerances.absolute_mip_gap; branch_and_bound_settings.relative_mip_gap_tol = context.settings.tolerances.relative_mip_gap; branch_and_bound_settings.integer_tol = context.settings.tolerances.integrality_tolerance; + branch_and_bound_settings.max_cut_passes = context.settings.max_cut_passes; + branch_and_bound_settings.mir_cuts = context.settings.mir_cuts; + branch_and_bound_settings.mixed_integer_gomory_cuts = context.settings.mixed_integer_gomory_cuts; + branch_and_bound_settings.knapsack_cuts = context.settings.knapsack_cuts; + branch_and_bound_settings.strong_chvatal_gomory_cuts = context.settings.strong_chvatal_gomory_cuts; if (context.settings.num_cpu_threads < 0) { branch_and_bound_settings.num_threads = omp_get_max_threads() - 1; @@ -204,7 +212,7 @@ solution_t mip_solver_t::run_solver() // Create the branch and bound object branch_and_bound = std::make_unique>( - branch_and_bound_problem, branch_and_bound_settings); + branch_and_bound_problem, branch_and_bound_settings, timer_.get_tic_start()); context.branch_and_bound_ptr = branch_and_bound.get(); branch_and_bound->set_concurrent_lp_root_solve(true); diff --git a/cpp/src/utilities/timer.hpp b/cpp/src/utilities/timer.hpp index 1d1a4881e..2838ab832 100644 --- a/cpp/src/utilities/timer.hpp +++ b/cpp/src/utilities/timer.hpp @@ -55,6 +55,35 @@ class timer_t { double get_time_limit() const noexcept { return time_limit; } + double get_tic_start() const noexcept + { + /** + * Converts a std::chrono::steady_clock::time_point to a struct timeval. + * This is an approximate conversion because steady_clock is relative to an + * unspecified epoch (e.g., system boot time), not the system clock epoch (UTC). + */ + // Get the current time from both clocks at approximately the same instant + std::chrono::system_clock::time_point sys_now = std::chrono::system_clock::now(); + std::chrono::steady_clock::time_point steady_now = std::chrono::steady_clock::now(); + + // Calculate the difference between the given steady_clock time point and the current steady + // time + auto diff_from_now = begin - steady_now; + + // Apply that same difference to the current system clock time point + std::chrono::system_clock::time_point sys_t = sys_now + diff_from_now; + + // Convert the resulting system_clock time point to microseconds since the system epoch + auto us_since_epoch = + std::chrono::duration_cast(sys_t.time_since_epoch()); + + // Populate the timeval struct + double tv_sec = us_since_epoch.count() / 1000000; + double tv_usec = us_since_epoch.count() % 1000000; + + return tv_sec + 1e-6 * tv_usec; + } + private: double time_limit; steady_clock::time_point begin; diff --git a/cpp/tests/dual_simplex/unit_tests/solve.cpp b/cpp/tests/dual_simplex/unit_tests/solve.cpp index 7aed72fe0..66a2347d1 100644 --- a/cpp/tests/dual_simplex/unit_tests/solve.cpp +++ b/cpp/tests/dual_simplex/unit_tests/solve.cpp @@ -326,4 +326,155 @@ TEST(dual_simplex, dual_variable_greater_than) EXPECT_NEAR(solution.z[1], 0.0, 1e-6); } +#if 0 +TEST(dual_simplex, simple_cuts) +{ + // minimize x + y + 2 z + // subject to x + y + z == 1 + // x, y, z >= 0 + + raft::handle_t handle{}; + cuopt::linear_programming::dual_simplex::user_problem_t user_problem(&handle); + constexpr int m = 1; + constexpr int n = 3; + constexpr int nz = 3; + + user_problem.num_rows = m; + user_problem.num_cols = n; + user_problem.objective.resize(n); + user_problem.objective[0] = 1.0; + user_problem.objective[1] = 1.0; + user_problem.objective[2] = 2.0; + user_problem.A.m = m; + user_problem.A.n = n; + user_problem.A.nz_max = nz; + user_problem.A.reallocate(nz); + user_problem.A.col_start.resize(n + 1); + user_problem.A.col_start[0] = 0; + user_problem.A.col_start[1] = 1; + user_problem.A.col_start[2] = 2; + user_problem.A.col_start[3] = 3; + user_problem.A.i[0] = 0; + user_problem.A.x[0] = 1.0; + user_problem.A.i[1] = 0; + user_problem.A.x[1] = 1.0; + user_problem.A.i[2] = 0; + user_problem.A.x[2] = 1.0; + user_problem.lower.resize(n, 0.0); + user_problem.upper.resize(n, dual_simplex::inf); + user_problem.num_range_rows = 0; + user_problem.problem_name = "simple_cuts"; + user_problem.obj_scale = 1.0; + user_problem.obj_constant = 0.0; + user_problem.rhs.resize(m, 1.0); + user_problem.row_sense.resize(m, 'E'); + user_problem.var_types.resize( + n, cuopt::linear_programming::dual_simplex::variable_type_t::CONTINUOUS); + + cuopt::init_logger_t logger("", true); + + cuopt::linear_programming::dual_simplex::lp_problem_t lp( + user_problem.handle_ptr, 1, 1, 1); + cuopt::linear_programming::dual_simplex::simplex_solver_settings_t settings; + settings.barrier = false; + settings.barrier_presolve = false; + settings.log.log = true; + settings.log.log_to_console = true; + settings.log.printf("Test print\n"); + std::vector new_slacks; + cuopt::linear_programming::dual_simplex::dualize_info_t dualize_info; + cuopt::linear_programming::dual_simplex::convert_user_problem( + user_problem, settings, lp, new_slacks, dualize_info); + cuopt::linear_programming::dual_simplex::lp_solution_t solution(lp.num_rows, + lp.num_cols); + std::vector vstatus; + std::vector edge_norms; + std::vector basic_list(lp.num_rows); + std::vector nonbasic_list; + cuopt::linear_programming::dual_simplex::basis_update_mpf_t basis_update( + lp.num_cols, settings.refactor_frequency); + double start_time = dual_simplex::tic(); + printf("Calling solve linear program with advanced basis\n"); + EXPECT_EQ((cuopt::linear_programming::dual_simplex::solve_linear_program_with_advanced_basis( + lp, + start_time, + settings, + solution, + basis_update, + basic_list, + nonbasic_list, + vstatus, + edge_norms)), + cuopt::linear_programming::dual_simplex::lp_status_t::OPTIMAL); + printf("Solution objective: %e\n", solution.objective); + printf("Solution x: %e %e %e\n", solution.x[0], solution.x[1], solution.x[2]); + printf("Solution y: %e\n", solution.y[0]); + printf("Solution z: %e %e %e\n", solution.z[0], solution.z[1], solution.z[2]); + EXPECT_NEAR(solution.objective, 1.0, 1e-6); + EXPECT_NEAR(solution.x[0], 1.0, 1e-6); + + // Add a cut z >= 1/3. Needs to be in the form C*x <= d + csr_matrix_t cuts(1, n, 1); + cuts.row_start[0] = 0; + cuts.j[0] = 2; + cuts.x[0] = -1.0; + cuts.row_start[1] = 1; + printf("cuts m %d n %d\n", cuts.m, cuts.n); + std::vector cut_rhs(1); + cut_rhs[0] = -1.0 / 3.0; + + std::vector var_types; + EXPECT_EQ(cuopt::linear_programming::dual_simplex::solve_linear_program_with_cuts(start_time, + settings, + cuts, + cut_rhs, + lp, + solution, + basis_update, + basic_list, + nonbasic_list, + vstatus, + edge_norms, + var_types), + cuopt::linear_programming::dual_simplex::lp_status_t::OPTIMAL); + printf("Solution objective: %e\n", solution.objective); + printf("Solution x: %e %e %e\n", solution.x[0], solution.x[1], solution.x[2]); + EXPECT_NEAR(solution.objective, 4.0 / 3.0, 1e-6); + + cuts.row_start.resize(3); + cuts.j.resize(2); + cuts.x.resize(2); + // Add cut y >= 1/3 + cuts.j[0] = 1; + cuts.row_start[2] = 2; + // Add cut x <= 0.0 + cuts.j[1] = 0; + cuts.x[1] = 1.0; + cuts.m = 2; + cut_rhs.resize(2); + cut_rhs[1] = 0.0; + + EXPECT_EQ(cuopt::linear_programming::dual_simplex::solve_linear_program_with_cuts(start_time, + settings, + cuts, + cut_rhs, + lp, + solution, + basis_update, + basic_list, + nonbasic_list, + vstatus, + edge_norms, + var_types), + cuopt::linear_programming::dual_simplex::lp_status_t::OPTIMAL); + printf("Solution objective: %e\n", solution.objective); + printf("Solution x: %e %e %e\n", solution.x[0], solution.x[1], solution.x[2]); + EXPECT_NEAR(solution.objective, 4.0 / 3.0, 1e-6); + EXPECT_NEAR(solution.x[0], 0.0, 1e-6); + EXPECT_NEAR(solution.x[1], 2.0 / 3.0, 1e-6); + EXPECT_NEAR(solution.x[2], 1.0 / 3.0, 1e-6); + +} +#endif + } // namespace cuopt::linear_programming::dual_simplex::test