static_matrix<T, X>::static_matrix(static_matrix const &A, unsigned * /* basis */) :
m_work_pivot_vector(A.row_count(), numeric_traits<T>::zero()) {
unsigned m = A.row_count();
init_row_columns(m, m);
while (m--) {
for (auto & col : A.m_columns[m]){
set(col.m_i, m, A.get_value_of_column_cell(col));
}
}
}
void lar_solver::fill_row_of_A(static_matrix<U, V> & A, unsigned i, canonic_left_side * ls) {
for (auto & t : ls->m_coeffs) {
var_index vi = t.second;
unsigned column = get_column_index_from_var_index(vi);
lean_assert(is_valid(column));
A.set(i, column, convert_struct<U, mpq>::convert(t.first));
}
unsigned additional_column = get_column_index_from_var_index(ls->m_additional_var_index);
lean_assert(is_valid(additional_column));
A.set(i, additional_column, - one_of_type<U>());
}
void lar_solver::prepare_core_solver_fields(static_matrix<U, V> & A, std::vector<V> & x,
std::vector<V> & low_bound,
std::vector<V> & upper_bound) {
create_matrix_A(A);
fill_bounds_for_core_solver(low_bound, upper_bound);
if (m_status == INFEASIBLE) {
lean_assert(false); // not implemented
}
resize_and_init_x_with_zeros(x, A.column_count());
lean_assert(m_lar_core_solver_params.m_basis.size() == A.row_count());
}
void lar_solver::create_matrix_A(static_matrix<U, V> & A) {
unsigned m = m_set_of_canonic_left_sides.size();
fill_set_of_active_var_indices();
unsigned n = m_set_of_active_var_indices.size() + m;
A.init_empty_matrix(m, n);
unsigned i = 0;
for (auto t : m_set_of_canonic_left_sides) {
lean_assert(t->size() > 0);
if (is_valid(t->m_row_index))
fill_row_of_A(A, i++, t);
}
}
void assign( static_matrix<T,Row,Col>&src, dynamic_matrix<T>& dst )
{
assert(dst.row()==Row);
assert(dst.col()==Col);
memcpy(src.begin(), dst.begin(), Row*Col*sizeof(T));
}
void assign( static_matrix<U,Row,Col>&src, dynamic_matrix<T>& dst )
{
assert(dst.row()==Row);
assert(dst.col()==Col);
std::copy(src.begin(), src.end(), dst.begin());
}
