Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 5 additions & 0 deletions include/core/Debugger.h
Original file line number Diff line number Diff line change
Expand Up @@ -130,6 +130,11 @@ void verify_row_tags(const struct Constraints *constraints);
inactive columns when finished */
void verify_empty_when_finished(const struct Constraints *constraints);

/* An active, non-empty column whose bounds have met must be waiting in
State.equal_bound_cols, so that fix_cols_with_equal_bounds finds every column
that a sweep over all columns would find. */
void verify_equal_bounds_queued(const struct Constraints *constraints);

/* True when the empty-column worklist holds only columns that
remove_empty_cols keeps: columns in P whose row is not a positive diagonal
alone. The explorers assert this on entry. */
Expand Down
1 change: 1 addition & 0 deletions include/core/State.h
Original file line number Diff line number Diff line change
Expand Up @@ -50,6 +50,7 @@ typedef struct State
/* row sizes of P, SIZE_INACTIVE_COL for removed variables, NULL for an LP */
int *P_row_sizes;

iVec *equal_bound_cols;
iVec *fixed_cols_to_delete;
iVec *sub_cols_to_delete;
iVec *rows_to_delete;
Expand Down
2 changes: 2 additions & 0 deletions include/core/pslp_namespace.h
Original file line number Diff line number Diff line change
Expand Up @@ -92,6 +92,7 @@
#define fix_col pslp_fix_col
#define fix_col_to_negative_inf pslp_fix_col_to_negative_inf
#define fix_col_to_positive_inf pslp_fix_col_to_positive_inf
#define fix_cols_with_equal_bounds pslp_fix_cols_with_equal_bounds
#define fix_var_in_obj pslp_fix_var_in_obj
#define fold_apply pslp_fold_apply
#define fold_check pslp_fold_check
Expand Down Expand Up @@ -243,6 +244,7 @@
#define verify_empty_cols pslp_verify_empty_cols
#define verify_empty_rows pslp_verify_empty_rows
#define verify_empty_when_finished pslp_verify_empty_when_finished
#define verify_equal_bounds_queued pslp_verify_equal_bounds_queued
#define verify_locks pslp_verify_locks
#define verify_no_duplicates pslp_verify_no_duplicates
#define verify_no_duplicates_lists pslp_verify_no_duplicates_lists
Expand Down
7 changes: 5 additions & 2 deletions include/explorers/SimpleReductions.h
Original file line number Diff line number Diff line change
Expand Up @@ -111,9 +111,12 @@ PresolveStatus check_activities(struct Problem *prob);
*/
PresolveStatus remove_empty_cols(struct Problem *prob);

/* Fixes every column whose bounds are equal, or within FEAS_TOL when
is_fixing_negligible holds. Run once, on the input bounds. */
PresolveStatus remove_variables_with_close_bounds(struct Problem *prob);

// only used for debugging purposes
// void fix_cols_with_equal_bounds(struct Constraints *constraints);
/* Fixes the columns that update_lb and update_ub queued in
State.equal_bound_cols because their bounds met (lb >= ub or IS_EQUAL_REL). */
void fix_cols_with_equal_bounds(struct Problem *prob);

#endif // SIMPLEREDUCTIONS_H
19 changes: 12 additions & 7 deletions src/core/CoreTransformation.c
Original file line number Diff line number Diff line change
Expand Up @@ -260,10 +260,12 @@ PresolveStatus update_lb_with_row(Constraints *constraints, int col, double new_
save_retrieval_bound_change_the_row(data->postsolve_info, row, row_cols,
row_vals, row_len, 1);

// TODO: should we check for variable fixing here? And we could potentially
// get rid of remove_variables_with_close_bounds from trivial presolve
// and just run it once in the beginning? But we don't have access to ck
// here.
// check for fixed variable
if (!HAS_TAG(*col_tag, C_TAG_UB_INF) &&
(new_lb >= ub || IS_EQUAL_REL(new_lb, ub)))
{
iVec_append(data->equal_bound_cols, col);
}
}

return UNCHANGED;
Expand Down Expand Up @@ -321,9 +323,12 @@ PresolveStatus update_ub_with_row(Constraints *constraints, int col, double new_
save_retrieval_bound_change_the_row(data->postsolve_info, row, row_cols,
row_vals, row_len, 1);

// TODO: should we check for variable fixing here? And we could potentially
// get rid of remove_variables_with_close_bounds from trivial presolve
// and just run it once in the beginning?
// check for fixed variable
if (!HAS_TAG(*col_tag, C_TAG_LB_INF) &&
(new_ub <= lb || IS_EQUAL_REL(new_ub, lb)))
{
iVec_append(data->equal_bound_cols, col);
}
}

return UNCHANGED;
Expand Down
26 changes: 26 additions & 0 deletions src/core/Debugger.c
Original file line number Diff line number Diff line change
Expand Up @@ -61,10 +61,36 @@ void run_debugger(const Constraints *constraints, bool finished)
}
}

void verify_equal_bounds_queued(const Constraints *constraints)
{
const State *data = constraints->state;

for (int k = 0; k < (int) constraints->n; ++k)
{
if (data->col_sizes[k] <= 0 ||
HAS_TAG(constraints->col_tags[k],
(C_TAG_INACTIVE | C_TAG_LB_INF | C_TAG_UB_INF)))
{
continue;
}

double lb = constraints->bounds[k].lb, ub = constraints->bounds[k].ub;
if (lb >= ub || IS_EQUAL_REL(lb, ub))
{
PSLP_ASSERT(iVec_contains(data->equal_bound_cols, k));
}
}
}

void run_debugger_problem(const Problem *prob, bool finished)
{
run_debugger(prob->constraints, finished);
verify_P(prob, finished);
if (!finished)
{
verify_equal_bounds_queued(prob->constraints);
}

if (finished)
{
PSLP_ASSERT(empty_cols_drained(prob));
Expand Down
14 changes: 8 additions & 6 deletions src/core/Presolver.c
Original file line number Diff line number Diff line change
Expand Up @@ -474,7 +474,8 @@ Presolver *new_presolver_from_problem(const ProblemData *problem,
presolver->stats->n_cones_original = n_cones;
presolver->stats->n_cone_rows_original = n_rows - first_cone_row;
presolver->reduced_prob = (ProblemData *) ps_calloc(1, sizeof(ProblemData));
DEBUG(run_debugger_problem(presolver->prob, false));
DEBUG(run_debugger(presolver->prob->constraints, false));
DEBUG(verify_P(presolver->prob, false));

clock_gettime(CLOCK_MONOTONIC, &timer.end);
presolver->stats->time_lp_fold = fold_time;
Expand Down Expand Up @@ -582,10 +583,7 @@ static inline PresolveStatus run_trivial_explorers(Problem *prob,
{
PresolveStatus status = UNCHANGED;

// TODO: should we just run this once in the beginning of presolve?
// Very important question.
status = remove_variables_with_close_bounds(prob);
RETURN_IF_INFEASIBLE(status);
fix_cols_with_equal_bounds(prob);

if (stgs->dual_fix)
{
Expand Down Expand Up @@ -896,7 +894,11 @@ PresolveStatus run_presolver(Presolver *presolver)
print_start_message(stats);
}

DEBUG(run_debugger_problem(prob, false));
// initial check for variables with closed bounds
nnz_before_reduction = A->nnz;
status = remove_variables_with_close_bounds(prob);
stats->nnz_removed_trivial += nnz_before_reduction - A->nnz;
terminate = (status != UNCHANGED);

// ------------------------------------------------------------------------
// Main loop for the presolver. The logic is organized into phases and
Expand Down
8 changes: 6 additions & 2 deletions src/core/State.c
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,7 @@
#define MIN_INIT_EMPTY_COLS 50
#define INIT_EMPTY_COLS_FRACTION 0.001
#define MIN_INIT_FIXED_COLS 1000
#define MIN_INIT_EQUAL_BOUND_COLS 100
#define INIT_FIXED_COLS_FRACTION 0.01
#define MIN_INIT_SUB_COLS 1000
#define INIT_SUB_COLS_FRACTION 0.01
Expand Down Expand Up @@ -83,14 +84,16 @@ State *new_state(int *row_sizes, int *col_sizes, int *P_row_sizes, Lock *col_loc
data->empty_cols = iVec_new(MAX(MIN_INIT_EMPTY_COLS, len_empty_cols));
data->empty_rows = iVec_new(MAX(MIN_INIT_EMPTY_ROWS, len_empty_rows));
data->updated_activities = iVec_new(MAX(MIN_INIT_UPDATED_ACTS, len_updated_act));
data->equal_bound_cols = iVec_new(MIN_INIT_EQUAL_BOUND_COLS);
data->fixed_cols_to_delete = iVec_new(MAX(MIN_INIT_FIXED_COLS, len_fixed_cols));
data->sub_cols_to_delete = iVec_new(MAX(MIN_INIT_SUB_COLS, len_sub_cols));
data->rows_to_delete = iVec_new(MAX(MIN_INIT_ROWS_TO_DELETE, len_rows_delete));
data->postsolve_info = postsolve_info_new(n_rows, n_cols);

if (!data->ston_rows || !data->ston_cols || !data->dton_rows ||
!data->empty_cols || !data->empty_rows || !data->fixed_cols_to_delete ||
!data->sub_cols_to_delete || !data->rows_to_delete || !data->postsolve_info)
!data->empty_cols || !data->empty_rows || !data->equal_bound_cols ||
!data->fixed_cols_to_delete || !data->sub_cols_to_delete ||
!data->rows_to_delete || !data->postsolve_info)
{
free_state(data);
return NULL;
Expand Down Expand Up @@ -165,6 +168,7 @@ void free_state(State *data)
iVec_free(data->empty_cols);
iVec_free(data->empty_rows);
iVec_free(data->updated_activities);
iVec_free(data->equal_bound_cols);
iVec_free(data->fixed_cols_to_delete);
iVec_free(data->sub_cols_to_delete);
iVec_free(data->rows_to_delete);
Expand Down
61 changes: 49 additions & 12 deletions src/explorers/SimpleReductions.c
Original file line number Diff line number Diff line change
Expand Up @@ -750,6 +750,23 @@ void clean_small_coeff_A(Matrix *A, const Bound *bounds, const RowTag *row_tags,
}
}

/* The value a column with close bounds is fixed at: an integral bound if
there is one, else the midpoint. */
static inline double value_between_bounds(Bound bound)
{
if (IS_INTEGRAL(bound.lb))
{
return bound.lb;
}

if (IS_INTEGRAL(bound.ub))
{
return bound.ub;
}

return 0.5 * (bound.lb + bound.ub);
}

PresolveStatus remove_variables_with_close_bounds(Problem *prob)
{
Constraints *constraints = prob->constraints;
Expand Down Expand Up @@ -785,18 +802,7 @@ PresolveStatus remove_variables_with_close_bounds(Problem *prob)
(IS_EQUAL_REL(bounds[ii].lb, bounds[ii].ub) ||
is_fixing_negligible(constraints, (int) ii, width)))
{
// fix at integral bound or at midpoint
double lb = bounds[ii].lb, ub = bounds[ii].ub;
double val = 0.5 * (lb + ub);
if (IS_INTEGRAL(lb))
{
val = lb;
}
else if (IS_INTEGRAL(ub))
{
val = ub;
}
fix_col(prob, (int) ii, val);
fix_col(prob, (int) ii, value_between_bounds(bounds[ii]));
}
}

Expand All @@ -805,3 +811,34 @@ PresolveStatus remove_variables_with_close_bounds(Problem *prob)
delete_inactive_cols_from_A_and_AT(constraints);
return UNCHANGED;
}

void fix_cols_with_equal_bounds(Problem *prob)
{
Constraints *constraints = prob->constraints;
const Bound *bounds = constraints->bounds;
const ColTag *col_tags = constraints->col_tags;
const int *col_sizes = constraints->state->col_sizes;
iVec *queue = constraints->state->equal_bound_cols;

for (size_t ii = 0; ii < queue->len; ++ii)
{
int col = queue->data[ii];
double lb = bounds[col].lb, ub = bounds[col].ub;

// Since it was queued the column can have been fixed, substituted or
// emptied (an empty column is left to remove_empty_cols), or merged
// with a parallel column, which widens its bounds.
if (col_sizes[col] <= 0 ||
HAS_TAG(col_tags[col], (C_TAG_INACTIVE | C_TAG_LB_INF | C_TAG_UB_INF)) ||
!(lb >= ub || IS_EQUAL_REL(lb, ub)))
{
continue;
}

fix_col(prob, col, value_between_bounds(bounds[col]));
}

iVec_clear_no_resize(queue);
delete_fixed_cols_from_problem(prob);
delete_inactive_cols_from_A_and_AT(constraints);
}
85 changes: 85 additions & 0 deletions tests/test_pathological.h
Original file line number Diff line number Diff line change
Expand Up @@ -250,6 +250,88 @@ static const char *test_unbounded_Zedongs_example()
return 0;
}

/* A feasible LP that used to be declared infeasible. With cap = 1 (row 0) and
v = 9e-7:
-v cap + x_k + y_k = 0 (k = 1, 2, 3), -(y_1 + y_2 + y_3) >= 0,
and x, y >= 0, so y = 0 and x_k = v. The doubleton rows give x_k in [0, v],
an interval below the feasibility tolerance. Fixing x_k anywhere but at v
leaves y_k > 0, and the three shifts add up to 2.7e-6 on the last row. */
static const char *test_derived_narrow_intervals_are_not_fixed()
{
double v = 9e-7;
double Ax[] = {1, -v, 1, 1, -v, 1, 1, -v, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1};
int Ai[] = {0, 0, 1, 4, 0, 2, 5, 0, 3, 6, 4, 5, 6, 1, 2, 3, 0, 1, 2, 3};
int Ap[] = {0, 1, 4, 7, 10, 13, 16, 20};
int nnz = 20;
int n_rows = 7;
int n_cols = 7;

double lhs[] = {1, 0, 0, 0, 0, -INF, -5};
double rhs[] = {1, 0, 0, 0, INF, 10, INF};
double lbs[] = {0, 0, 0, 0, 0, 0, 0};
double ubs[] = {INF, INF, INF, INF, INF, INF, INF};
double c[] = {0, 1, 1, 1, 0, 0, 0};

Settings *stgs = default_settings();
set_settings_true(stgs);
Presolver *presolver =
new_presolver(Ax, Ai, Ap, n_rows, n_cols, nnz, lhs, rhs, lbs, ubs, c, stgs);

PresolveStatus status = run_presolver(presolver);
mu_assert("derived narrow intervals: feasible LP declared infeasible",
status == REDUCED);
mu_assert("derived narrow intervals: reduced problem not empty",
presolver->reduced_prob->n == 0 && presolver->reduced_prob->m == 0);

postsolve(presolver, NULL, NULL, NULL);
const double *x = presolver->sol->x;
mu_assert("derived narrow intervals: cap", x[0] == 1.0);
for (int k = 1; k <= 3; ++k)
{
mu_assert("derived narrow intervals: x_k = v", ABS(x[k] - v) <= 1e-15);
mu_assert("derived narrow intervals: y_k = 0", ABS(x[k + 3]) <= 1e-15);
}

free_presolver(presolver);
free_settings(stgs);
return 0;
}

/* The close-bound fixings that must survive: x0 has the input bounds
[0, 1e-8] and is fixed by the sweep over the input, and the singleton row
x1 >= 1 makes the bounds of x1 equal, which fixes it through the queue of
the bound updates. */
static const char *test_close_input_bounds_and_equal_bounds_are_fixed()
{
double Ax[] = {1, 1, 1, 1, 1, 1, -1};
int Ai[] = {0, 2, 3, 1, 1, 2, 3};
int Ap[] = {0, 3, 4, 7};
int nnz = 7;
int n_rows = 3;
int n_cols = 4;

double lhs[] = {-INF, 1, -INF};
double rhs[] = {4, INF, 3};
double lbs[] = {0, 0, 0, 0};
double ubs[] = {1e-8, 1, 5, 5};
double c[] = {1, 1, -1, -2};

// only the trivial explorers
Settings *stgs = default_settings();
set_settings_false(stgs);
Presolver *presolver =
new_presolver(Ax, Ai, Ap, n_rows, n_cols, nnz, lhs, rhs, lbs, ubs, c, stgs);

PresolveStatus status = run_presolver(presolver);
mu_assert("close bounds: status", status == REDUCED);
mu_assert("close bounds: x0 and x1 not removed",
presolver->reduced_prob->n == 2 && presolver->reduced_prob->m == 2);

free_presolver(presolver);
free_settings(stgs);
return 0;
}

/* A feasible LP in which x2 lies in an interval of width 1e-8:
-1e-8 x0 + 1e-8 x1 + x2 = 1, -x0 + x1 >= 0.25, 0 <= x <= 1,
with x2 >= lb2. Fixing x2 inside the interval leaves a first row of the
Expand Down Expand Up @@ -304,6 +386,9 @@ static const char *test_close_bounds_are_not_fixed()

static const char *all_tests_pathological()
{
mu_run_test(test_derived_narrow_intervals_are_not_fixed, counter_pathological);
mu_run_test(test_close_input_bounds_and_equal_bounds_are_fixed,
counter_pathological);
mu_run_test(test_narrow_interval_is_not_fixed, counter_pathological);
mu_run_test(test_close_bounds_are_not_fixed, counter_pathological);
mu_run_test(test_zedongs_example, counter_pathological);
Expand Down
Loading