template <typename T, typename X> void core_solver_pretty_printer<T, X>::init_rs_width() {
m_rs_width = T_to_string(m_core_solver.get_cost()).size();
for (unsigned i = 0; i < nrows(); i++) {
auto wt = T_to_string(m_rs[i]).size();
if (wt > m_rs_width) {
m_rs_width = wt;
}
}
}
void ConfigFile::parseLine(const std::string &line, size_t const lineNo)
{
if (line.find('=') == line.npos)
std::cout << "CFG: Couldn't find separator on line: " << T_to_string(lineNo) << "\n" << std::endl;
if (!validLine(line))
std::cout << "CFG: Bad format for line: " << T_to_string(lineNo) << "\n" << std::endl;
extractContents(line);
}
template <typename T, typename X> unsigned core_solver_pretty_printer<T, X>:: get_column_width(unsigned column) {
unsigned w = std::max(m_costs[column].size(), T_to_string(m_core_solver.m_x[column]).size());
adjust_width_with_bounds(column, w);
adjust_width_with_basis_heading(column, w);
for (unsigned i = 0; i < nrows(); i++) {
unsigned cellw = m_A[i][column].size();
if (cellw > w) {
w = cellw;
}
}
w = std::max(w, (unsigned)T_to_string(m_exact_column_norms[column]).size());
w = std::max(w, (unsigned)T_to_string(m_core_solver.m_column_norms[column]).size());
return w;
}
std::string lar_solver::get_variable_name(var_index vi) const {
auto it = m_map_from_var_index_to_column_info_with_cls.find(vi);
if (it == m_map_from_var_index_to_column_info_with_cls.end()) {
std::string s = "variable " + T_to_string(vi) + " is not found";
return s;
}
return it->second.m_column_info.get_name();
}
// ********** print region start
void lar_solver::print_constraint(constraint_index ci, std::ostream & out) {
if (m_normalized_constraints.size() <= ci) {
std::string s = "constraint " + T_to_string(ci) + " is not found";
out << s << std::endl;
return;
}
print_constraint(&m_normalized_constraints[ci], out);
}
void print_matrix(matrix<T, X> const * m, std::ostream & out) {
std::vector<std::vector<std::string>> A(m->row_count());
for (unsigned i = 0; i < m->row_count(); i++) {
for (unsigned j = 0; j < m->column_count(); j++) {
A[i].push_back(T_to_string(m->get_elem(i, j)));
}
}
print_string_matrix(A, out);
}
template <typename T, typename X> std::string core_solver_pretty_printer<T, X>::get_upp_bound_string(unsigned j) {
switch (m_core_solver.get_column_type(j)){
case boxed:
case upper_bound:
case fixed:
return T_to_string(m_core_solver.upper_bound_value(j));
break;
default:
return std::string();
}
}
void lar_solver::fill_column_names() {
m_lar_core_solver_params.m_column_names.clear();
for (auto & t : m_map_from_var_index_to_column_info_with_cls) {
column_info<mpq> & ci = t.second.m_column_info;
unsigned j = ci.get_column_index();
lean_assert(is_valid(j));
std::string name = ci.get_name();
if (name.size() == 0)
name = std::string("_s") + T_to_string(j);
m_lar_core_solver_params.m_column_names[j] = name;
}
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::print_approx_norms() {
int blanks = m_title_width + 1 - m_approx_norm_title.size();
m_out << m_approx_norm_title;
print_blanks(blanks, m_out);
for (unsigned i = 0; i < ncols(); i++) {
string s = T_to_string(m_core_solver.m_column_norms[i]);
int blanks = m_column_widths[i] - s.size();
print_blanks(blanks, m_out);
m_out << s << " ";
}
m_out << std::endl;
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::set_coeff(vector<string>& row, vector<string> & row_signs, unsigned col, const T & t, string name) {
if (numeric_traits<T>::is_zero(t)) {
return;
}
if (col > 0) {
if (t > 0) {
row_signs[col] = "+";
row[col] = t != 1? T_to_string(t) + name : name;
} else {
row_signs[col] = "-";
row[col] = t != -1? T_to_string(-t) + name: name;
}
} else { // col == 0
if (t == -1) {
row[col] = "-" + name;
} else if (t == 1) {
row[col] = name;
} else {
row[col] = T_to_string(t) + name;
}
}
}
template <typename T, typename X> std::string core_solver_pretty_printer<T, X>::get_low_bound_string(unsigned j) {
switch (m_core_solver.get_column_type(j)){
case boxed:
case low_bound:
case fixed:
if (m_core_solver.low_bounds_are_set())
return T_to_string(m_core_solver.low_bound_value(j));
else
return std::string("0");
break;
default:
return std::string();
}
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::print_basis_heading() {
int blanks = m_title_width + 1 - m_basis_heading_title.size();
m_out << m_basis_heading_title;
print_blanks(blanks, m_out);
if (ncols() == 0) {
return;
}
auto bh = m_core_solver.m_basis_heading;
for (unsigned i = 0; i < ncols(); i++) {
string s = T_to_string(bh[i]);
int blanks = m_column_widths[i] - s.size();
print_blanks(blanks, m_out);
m_out << s << " "; // the column interval
}
m_out << std::endl;
}
void lar_solver::print_canonic_left_side(const canonic_left_side & c, std::ostream & out) {
bool first = true;
for (auto & it : c.m_coeffs) {
auto val = it.first;
if (first) {
first = false;
} else {
if (val.is_pos()) {
out << " + ";
} else {
out << " - ";
val = -val;
}
}
if (val != numeric_traits<mpq>::one())
out << T_to_string(val);
out << get_variable_name(it.second);
}
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::print_given_rows(vector<string> & row, vector<string> & signs, X rst) {
for (unsigned col = 0; col < row.size(); col++) {
unsigned width = m_column_widths[col];
string s = row[col];
int number_of_blanks = width - s.size();
lean_assert(number_of_blanks >= 0);
print_blanks(number_of_blanks, m_out);
m_out << s << ' ';
if (col < row.size() - 1) {
m_out << signs[col + 1] << ' ';
}
}
m_out << '=';
string rs = T_to_string(rst);
int nb = m_rs_width - rs.size();
lean_assert(nb >= 0);
print_blanks(nb + 1, m_out);
m_out << rs << std::endl;
}
canonic_left_side * lar_solver::create_or_fetch_existing_left_side(const buffer<std::pair<mpq, var_index>>& left_side_par) {
auto left_side = new canonic_left_side(left_side_par);
lean_assert(left_side->size() > 0);
auto it = m_set_of_canonic_left_sides.find(left_side);
if (it == m_set_of_canonic_left_sides.end()) {
m_set_of_canonic_left_sides.insert(left_side);
lean_assert(m_map_from_var_index_to_column_info_with_cls.find(m_available_var_index) == m_map_from_var_index_to_column_info_with_cls.end());
unsigned vj = m_available_var_index;
m_map_from_var_index_to_column_info_with_cls[vj] = column_info_with_cls(left_side);
m_map_from_var_index_to_column_info_with_cls[vj].m_column_info.set_name("_s" + T_to_string(vj));
left_side->m_additional_var_index = vj;
m_available_var_index++;
} else {
delete left_side;
left_side = *it;
}
return left_side;
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::adjust_width_with_upper_bound(unsigned column, unsigned & w) {
w = std::max(w, (unsigned)T_to_string(m_core_solver.upper_bound_value(column)).size());
}
template <typename T, typename X> void core_solver_pretty_printer<T, X>::adjust_width_with_low_bound(unsigned column, unsigned & w) {
if (!m_core_solver.low_bounds_are_set()) return;
w = std::max(w, (unsigned)T_to_string(m_core_solver.low_bound_value(column)).size());
}
template <typename T, typename X> std::string core_solver_pretty_printer<T, X>::regular_cell_string(unsigned row, unsigned /* column */, std::string name) {
T t = fabs(m_core_solver.m_ed[row]);
if ( t == 1) return name;
return T_to_string(t) + name;
}
