void matrix_chain_multiply_order (Matrix *ma[], int len, Matrix *m, Matrix *s)
{
int i, j, k, l;
int q;
int n = len;
for (i = 1; i <= n; i++)
{
matrix_set_value (m, i, i, 0);
}
for (l = 2; l <= n; l++)
{
for (i = 1; i <= (n - l + 1); i++)
{
j = (i + l - 1);
matrix_set_value (m, i, j, INT_MAX_SENTINEL);
for (k = i; k <= (j - 1); k++)
{
q = matrix_get_value (m, i, k) + matrix_get_value (m, k + 1, j) + matrix_chain_get_dimensions (ma, len, i - 1, k, j);
if (q < matrix_get_value (m, i, j))
{
matrix_set_value (m, i, j, q);
matrix_set_value (s, i, j, k);
}
}
}
}
}
// m : h x w (h: dimension, w: tries)
static int matrix_self_gram_schmidt_process(matrix_t *m, int x, int y, int w, int h)
{
int i, j, k;
real_t u, v, *u_vec;
real_t c, d;
u_vec = (real_t *)malloc(h * sizeof(real_t));
// Step 1. Let U0 = V0
// nothing to do
for (i = x + 1; i < x + w; i++) {
// Step 2.
// U(i) = V(i) - proj_{U(0)}(V(i)) - proj_{U(1)}(V(i)) - ....
// proj_{U}(V) = (<U,V> / <U,U>) * U
// U(i) = V(i)
for (k = 0; k < h; k++) u_vec[k] = matrix_get_value(m, i, y + k);
for (j = x; j < i; j++) {
// U(i) -= proj_{U(j)}(V(i))
c = d = 0;
for (k = y; k < y + h; k++) {
v = matrix_get_value(m, i, k);
u = matrix_get_value(m, j, k);
c += u * v;
d += u * u;
}
c /= d;
for (k = y; k < y + h; k++) {
u = matrix_get_value(m, j, k);
u_vec[k - y] -= c * u;
}
}
for (k = 0; k < h; k++) matrix_put_value(u_vec[k], m, i, y + k);
if (matrix_is_zero(m, i, y, 1, h)) break;
}
free(u_vec);
// normalization
for (j = x; j < i; j++) {
d = 0;
for (k = 0; k < h; k++) {
u = matrix_get_value(m, j, y + k);
d += u * u;
}
d = sqrt(d);
matrix_divide_scalar_on_region(m, d, j, y, 1, h);
}
return i - x;
}
static void matrix_chain_print_optimal_parens (Matrix *s, int i, int j)
{
if (i == j)
{
printf ("A%d", i);
}
else
{
printf ("(");
matrix_chain_print_optimal_parens (s, i, matrix_get_value (s, i, j));
matrix_chain_print_optimal_parens (s, matrix_get_value (s, i, j) + 1, j);
printf (")");
}
}
void matrix_resize(matrix_t* m, uint new_rows, uint new_cols) {
uint row_index, col_index;
double* new_v;
if (m->num_rows == new_rows && m->num_cols == new_cols) {
return;
}
new_v = (double*)malloc(new_rows * new_cols * sizeof(double));
// Zero-initialize the matrix.
memset(new_v, 0, new_rows * new_cols * sizeof(double));
// Copy the old values over.
for (row_index = 0; row_index < MIN(new_rows, m->num_rows); ++row_index) {
for (col_index = 0; col_index < MIN(new_cols, m->num_cols); ++ col_index) {
new_v[row_index*new_cols + col_index] = matrix_get_value(m, row_index, col_index);
}
}
free(m->values);
m->values = new_v;
m->num_rows = new_rows;
m->num_cols = new_cols;
}
static Matrix *matrix_chain_optimal_multiply (Matrix *ma[], Matrix *s, int i, int j)
{
int split;
Matrix *l;
Matrix *r;
if (i == j)
{
return (ma[i - 1]);
}
else
{
split = matrix_get_value (s, i, j);
l = matrix_chain_optimal_multiply (ma, s, i, split);
r = matrix_chain_optimal_multiply (ma, s, split + 1, j);
return (matrix_multiply (l, r));
}
}
