mirror of
https://github.com/Z3Prover/z3
synced 2025-10-09 09:21:56 +00:00
0a93ff515d
* Introduce X-macro-based trace tag definition - Created trace_tags.def to centralize TRACE tag definitions - Each tag includes a symbolic name and description - Set up enum class TraceTag for type-safe usage in TRACE macros * Add script to generate Markdown documentation from trace_tags.def - Python script parses trace_tags.def and outputs trace_tags.md * Refactor TRACE_NEW to prepend TraceTag and pass enum to is_trace_enabled * trace: improve trace tag handling system with hierarchical tagging - Introduce hierarchical tag-class structure: enabling a tag class activates all child tags - Unify TRACE, STRACE, SCTRACE, and CTRACE under enum TraceTag - Implement initial version of trace_tag.def using X(tag, tag_class, description) (class names and descriptions to be refined in a future update) * trace: replace all string-based TRACE tags with enum TraceTag - Migrated all TRACE, STRACE, SCTRACE, and CTRACE macros to use enum TraceTag values instead of raw string literals * trace : add cstring header * trace : Add Markdown documentation generation from trace_tags.def via mk_api_doc.py * trace : rename macro parameter 'class' to 'tag_class' and remove Unicode comment in trace_tags.h. * trace : Add TODO comment for future implementation of tag_class activation * trace : Disable code related to tag_class until implementation is ready (#7663).
114 lines
3.4 KiB
C++
114 lines
3.4 KiB
C++
/*++
|
|
Copyright (c) 2020 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
int_cube.cpp
|
|
|
|
Abstract:
|
|
|
|
Cube finder
|
|
|
|
Author:
|
|
Lev Nachmanson (levnach)
|
|
Nikolaj Bjorner (nbjorner)
|
|
|
|
Revision History:
|
|
--*/
|
|
|
|
#include "math/lp/int_solver.h"
|
|
#include "math/lp/lar_solver.h"
|
|
#include "math/lp/int_cube.h"
|
|
|
|
namespace lp {
|
|
|
|
int_cube::int_cube(int_solver& lia):lia(lia), lra(lia.lra) {}
|
|
|
|
lia_move int_cube::operator()() {
|
|
lia.settings().stats().m_cube_calls++;
|
|
TRACE(cube,
|
|
for (unsigned j = 0; j < lra.number_of_vars(); j++)
|
|
lia.display_column(tout, j);
|
|
tout << lra.constraints();
|
|
);
|
|
|
|
lra.push();
|
|
if (!tighten_terms_for_cube()) {
|
|
lra.pop();
|
|
lra.set_status(lp_status::OPTIMAL);
|
|
return lia_move::undef;
|
|
}
|
|
|
|
lp_status st = lra.find_feasible_solution();
|
|
if (st != lp_status::FEASIBLE && st != lp_status::OPTIMAL) {
|
|
TRACE(cube, tout << "cannot find a feasible solution";);
|
|
lra.pop();
|
|
lra.move_non_basic_columns_to_bounds();
|
|
// it can happen that we found an integer solution here
|
|
return !lra.r_basis_has_inf_int()? lia_move::sat: lia_move::undef;
|
|
}
|
|
lra.pop();
|
|
lra.round_to_integer_solution();
|
|
lra.set_status(lp_status::FEASIBLE);
|
|
SASSERT(lia.settings().get_cancel_flag() || lia.is_feasible());
|
|
TRACE(cube, tout << "success";);
|
|
lia.settings().stats().m_cube_success++;
|
|
return lia_move::sat;
|
|
}
|
|
// i is the column index having the term
|
|
bool int_cube::tighten_term_for_cube(unsigned i) {
|
|
if (!lra.column_associated_with_row(i))
|
|
return true;
|
|
const lar_term& t = lra.get_term(i);
|
|
impq delta = get_cube_delta_for_term(t);
|
|
TRACE(cube, lra.print_term_as_indices(t, tout); tout << ", delta = " << delta << "\n";);
|
|
if (is_zero(delta))
|
|
return true;
|
|
return lra.tighten_term_bounds_by_delta(i, delta);
|
|
}
|
|
|
|
bool int_cube::tighten_terms_for_cube() {
|
|
for (const lar_term* t: lra.terms())
|
|
if (!tighten_term_for_cube(t->j())) {
|
|
TRACE(cube, tout << "cannot tighten";);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void int_cube::find_feasible_solution() {
|
|
lra.find_feasible_solution();
|
|
SASSERT(lp_status::OPTIMAL == lra.get_status() || lp_status::FEASIBLE == lra.get_status());
|
|
}
|
|
|
|
impq int_cube::get_cube_delta_for_term(const lar_term& t) const {
|
|
if (t.size() == 2) {
|
|
bool seen_minus = false;
|
|
bool seen_plus = false;
|
|
for(lar_term::ival p : t) {
|
|
if (!lia.column_is_int(p.j()))
|
|
goto usual_delta;
|
|
const mpq & c = p.coeff();
|
|
if (c == one_of_type<mpq>()) {
|
|
seen_plus = true;
|
|
} else if (c == -one_of_type<mpq>()) {
|
|
seen_minus = true;
|
|
} else {
|
|
goto usual_delta;
|
|
}
|
|
}
|
|
if (seen_minus && seen_plus)
|
|
return zero_of_type<impq>();
|
|
return impq(0, 1);
|
|
}
|
|
usual_delta:
|
|
mpq delta = zero_of_type<mpq>();
|
|
for (lar_term::ival p : t)
|
|
if (lia.column_is_int(p.j()))
|
|
delta += abs(p.coeff());
|
|
|
|
delta *= mpq(1, 2);
|
|
return impq(delta);
|
|
}
|
|
|
|
}
|