mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-29 11:55:51 +00:00
Code Activity

Partial cleanup of util/lp/*

Browse source
This commit is contained in:
Christoph M. Wintersteiger 2017-09-17 16:00:06 +01:00
parent 00651f8f21
commit d61b722b68
109 changed files with 3503 additions and 2023 deletions
Download patch file Download diff file Expand all files Collapse all files

53
src/util/lp/lp_solver.hpp
View file

@ -1,12 +1,27 @@
/*
Copyright (c) 2017 Microsoft Corporation
Author: Lev Nachmanson
*/
/*++
Copyright (c) 2017 Microsoft Corporation
Module Name:
<name>
Abstract:
<abstract>
Author:
Lev Nachmanson (levnach)
Revision History:
--*/
#include <string>
#include <algorithm>
#include "util/vector.h"
#include "util/lp/lp_solver.h"
namespace lean {
namespace lp {
template <typename T, typename X> column_info<T> * lp_solver<T, X>::get_or_create_column_info(unsigned column) {
auto it = m_map_from_var_index_to_column_info.find(column);
return (it == m_map_from_var_index_to_column_info.end())? (m_map_from_var_index_to_column_info[column] = new column_info<T>(static_cast<unsigned>(-1))) : it->second;
@ -32,7 +47,7 @@ template <typename T, typename X> T lp_solver<T, X>::get_column_cost_value(unsig
return ci->get_cost() * get_column_value(j);
}
template <typename T, typename X> void lp_solver<T, X>::add_constraint(lp_relation relation, T right_side, unsigned row_index) {
lean_assert(m_constraints.find(row_index) == m_constraints.end());
SASSERT(m_constraints.find(row_index) == m_constraints.end());
lp_constraint<T, X> cs(right_side, relation);
m_constraints[row_index] = cs;
}
@ -158,10 +173,10 @@ template <typename T, typename X> void lp_solver<T, X>::pin_vars_on_row_with_sig
column_info<T> * ci = m_map_from_var_index_to_column_info[j];
T a = t.second;
if (a * sign > numeric_traits<T>::zero()) {
lean_assert(ci->upper_bound_is_set());
SASSERT(ci->upper_bound_is_set());
ci->set_fixed_value(ci->get_upper_bound());
} else {
lean_assert(ci->low_bound_is_set());
SASSERT(ci->low_bound_is_set());
ci->set_fixed_value(ci->get_low_bound());
}
}
@ -328,7 +343,7 @@ template <typename T, typename X> bool lp_solver<T, X>::row_is_obsolete(std::
case lp_relation::Less_or_equal:
return row_le_is_obsolete(row, row_index);
}
lean_unreachable();
SASSERT(false);
return false; // it is unreachable
}
@ -343,7 +358,7 @@ template <typename T, typename X> void lp_solver<T, X>::remove_fixed_or_zero_col
vector<unsigned> removed;
for (auto & col : row) {
unsigned j = col.first;
lean_assert(m_map_from_var_index_to_column_info.find(j) != m_map_from_var_index_to_column_info.end());
SASSERT(m_map_from_var_index_to_column_info.find(j) != m_map_from_var_index_to_column_info.end());
column_info<T> * ci = m_map_from_var_index_to_column_info[j];
if (ci->is_fixed()) {
removed.push_back(j);
@ -412,7 +427,7 @@ template <typename T, typename X> void lp_solver<T, X>::map_external_columns_to_
}
unsigned j = col.first;
auto column_info_it = m_map_from_var_index_to_column_info.find(j);
lean_assert(column_info_it != m_map_from_var_index_to_column_info.end());
SASSERT(column_info_it != m_map_from_var_index_to_column_info.end());
auto j_column = column_info_it->second->get_column_index();
if (!is_valid(j_column)) { // j is a newcomer
@ -435,14 +450,14 @@ template <typename T, typename X> void lp_solver<T, X>::fill_A_from_A_values() {
m_A = new static_matrix<T, X>(static_cast<unsigned>(m_A_values.size()), number_of_core_structurals());
for (auto & t : m_A_values) {
auto row_it = m_external_rows_to_core_solver_rows.find(t.first);
lean_assert(row_it != m_external_rows_to_core_solver_rows.end());
SASSERT(row_it != m_external_rows_to_core_solver_rows.end());
unsigned row = row_it->second;
for (auto k : t.second) {
auto column_info_it = m_map_from_var_index_to_column_info.find(k.first);
lean_assert(column_info_it != m_map_from_var_index_to_column_info.end());
SASSERT(column_info_it != m_map_from_var_index_to_column_info.end());
column_info<T> *ci = column_info_it->second;
unsigned col = ci->get_column_index();
lean_assert(is_valid(col));
SASSERT(is_valid(col));
bool col_is_flipped = m_map_from_var_index_to_column_info[k.first]->is_flipped();
if (!col_is_flipped) {
(*m_A)(row, col) = k.second;
@ -456,7 +471,7 @@ template <typename T, typename X> void lp_solver<T, X>::fill_A_from_A_values() {
template <typename T, typename X> void lp_solver<T, X>::fill_matrix_A_and_init_right_side() {
map_external_rows_to_core_solver_rows();
map_external_columns_to_core_solver_columns();
lean_assert(m_A == nullptr);
SASSERT(m_A == nullptr);
fill_A_from_A_values();
m_b.resize(m_A->row_count());
}
@ -468,7 +483,7 @@ template <typename T, typename X> void lp_solver<T, X>::count_slacks_and_artific
}
template <typename T, typename X> void lp_solver<T, X>::count_slacks_and_artificials_for_row(unsigned i) {
lean_assert(this->m_constraints.find(this->m_core_solver_rows_to_external_rows[i]) != this->m_constraints.end());
SASSERT(this->m_constraints.find(this->m_core_solver_rows_to_external_rows[i]) != this->m_constraints.end());
auto & constraint = this->m_constraints[this->m_core_solver_rows_to_external_rows[i]];
switch (constraint.m_relation) {
case Equal:
@ -504,7 +519,7 @@ template <typename T, typename X> T lp_solver<T, X>::low_bound_shift_for_row(
template <typename T, typename X> void lp_solver<T, X>::fill_m_b() {
for (int i = this->row_count() - 1; i >= 0; i--) {
lean_assert(this->m_constraints.find(this->m_core_solver_rows_to_external_rows[i]) != this->m_constraints.end());
SASSERT(this->m_constraints.find(this->m_core_solver_rows_to_external_rows[i]) != this->m_constraints.end());
unsigned external_i = this->m_core_solver_rows_to_external_rows[i];
auto & constraint = this->m_constraints[external_i];
this->m_b[i] = constraint.m_rs - low_bound_shift_for_row(external_i);
@ -542,13 +557,13 @@ template <typename T, typename X> T lp_solver<T, X>::get_column_value_with_core_
template <typename T, typename X> void lp_solver<T, X>::set_scaled_cost(unsigned j) {
// grab original costs but modify it with the column scales
lean_assert(j < this->m_column_scale.size());
SASSERT(j < this->m_column_scale.size());
column_info<T> * ci = this->m_map_from_var_index_to_column_info[this->m_core_solver_columns_to_external_columns[j]];
T cost = ci->get_cost();
if (ci->is_flipped()){
cost *= -1;
}
lean_assert(ci->is_fixed() == false);
SASSERT(ci->is_fixed() == false);
this->m_costs[j] = cost * this->m_column_scale[j];
}
}