private void fill_matrices(int item_count)
{
int num_vars = item_count + 2;
if (item_count != _last_item_count)
{
_vB = new int[num_vars];
_vN = new int[item_count];
_last_item_count = item_count;
}
int[] vB = _vB, vN = _vN;
List <solver_entry> items = this.items;
_E.set_to_identity(num_vars);
_cB.clear(1, num_vars);
_cN.clear(1, item_count);
_B.set_to_identity(num_vars);
_B_inv.clear(num_vars);
_N.clear(num_vars, item_count);
_b.clear(num_vars, 1);
//_B_inv.set_to_identity(num_vars);
_z.clear(1, num_vars);
_z_c.clear(1, item_count);
_result.clear(num_vars, 1);
_entering_column.clear(num_vars, 1);
_dividers.clear(num_vars, 1);
sparse_row_ref B0_ref = _B[0], B1_ref = _B[1];
int cur_index;
for (int cur_item = 0; cur_item < item_count; ++cur_item)
{
cur_index = cur_item + 2;
vB [cur_index] = cur_item;
vN [cur_item] = cur_item + num_vars;
B0_ref[cur_index] = items[cur_item].x;
B1_ref[cur_index] = items[cur_item].y;
_N[cur_index][cur_item] = 1.0;
_b[cur_index][0] = items[cur_item].max_value;
}
vB[0] = item_count;
vB[1] = item_count + 1;
}
static public void multiply(ref sparse_matrix result, sparse_matrix left, sparse_matrix right)
{
if (left._width != right._height)
{
throw new ArgumentException("Operand size mismatch");
}
Dictionary <int, double> result_row_ref, left_row_ref, right_row_ref;
double cur_element;
int cur_column;
result.clear(left._height, right._width);
int result_height = result._height;
Dictionary <int, double>[] result_contents = result._contents, left_contents = left._contents, right_contents = right._contents;
for (int cur_row = 0; cur_row < result_height; ++cur_row)
{
left_row_ref = left_contents[cur_row];
result_row_ref = result_contents[cur_row];
foreach (KeyValuePair <int, double> cur_diagonal in left_row_ref)
{
cur_element = cur_diagonal.Value;
right_row_ref = right_contents[cur_diagonal.Key];
foreach (KeyValuePair <int, double> cur_horizontal in right_row_ref)
{
cur_column = cur_horizontal.Key;
if (result_row_ref.ContainsKey(cur_column))
{
result_row_ref[cur_column] += cur_element * cur_horizontal.Value;
}
else
{
result_row_ref.Add(cur_column, cur_element * cur_horizontal.Value);
}
}
}
}
}