lambda_trans_matrix
lambda_trans_matrix_new (int colsize, int rowsize)
{
lambda_trans_matrix ret;
ret = GGC_NEW (struct lambda_trans_matrix_s);
LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize);
LTM_ROWSIZE (ret) = rowsize;
LTM_COLSIZE (ret) = colsize;
LTM_DENOMINATOR (ret) = 1;
return ret;
}
lambda_trans_matrix
lambda_trans_matrix_new (int colsize, int rowsize)
{
lambda_trans_matrix ret;
ret = ggc_alloc (sizeof (*ret));
LTM_MATRIX (ret) = lambda_matrix_new (rowsize, colsize);
LTM_ROWSIZE (ret) = rowsize;
LTM_COLSIZE (ret) = colsize;
LTM_DENOMINATOR (ret) = 1;
return ret;
}
void
lambda_matrix_project_to_null (lambda_matrix B, int rowsize,
int colsize, int k, lambda_vector x)
{
lambda_matrix M1, M2, M3, I;
int determinant;
/* Compute c(I-B^T inv(B B^T) B) e sub k. */
/* M1 is the transpose of B. */
M1 = lambda_matrix_new (colsize, colsize);
lambda_matrix_transpose (B, M1, rowsize, colsize);
/* M2 = B * B^T */
M2 = lambda_matrix_new (colsize, colsize);
lambda_matrix_mult (B, M1, M2, rowsize, colsize, rowsize);
/* M3 = inv(M2) */
M3 = lambda_matrix_new (colsize, colsize);
determinant = lambda_matrix_inverse (M2, M3, rowsize);
/* M2 = B^T (inv(B B^T)) */
lambda_matrix_mult (M1, M3, M2, colsize, rowsize, rowsize);
/* M1 = B^T (inv(B B^T)) B */
lambda_matrix_mult (M2, B, M1, colsize, rowsize, colsize);
lambda_matrix_negate (M1, M1, colsize, colsize);
I = lambda_matrix_new (colsize, colsize);
lambda_matrix_id (I, colsize);
lambda_matrix_add_mc (I, determinant, M1, 1, M2, colsize, colsize);
lambda_matrix_get_column (M2, colsize, k - 1, x);
}
static int
lambda_matrix_inverse_hard (lambda_matrix mat, lambda_matrix inv, int n)
{
lambda_vector row;
lambda_matrix temp;
int i, j;
int determinant;
temp = lambda_matrix_new (n, n);
lambda_matrix_copy (mat, temp, n, n);
lambda_matrix_id (inv, n);
/* Reduce TEMP to a lower triangular form, applying the same operations on
INV which starts as the identity matrix. N is the number of rows and
columns. */
for (j = 0; j < n; j++)
{
row = temp[j];
/* Make every element in the current row positive. */
for (i = j; i < n; i++)
if (row[i] < 0)
{
lambda_matrix_col_negate (temp, n, i);
lambda_matrix_col_negate (inv, n, i);
}
/* Sweep the upper triangle. Stop when only the diagonal element in the
current row is nonzero. */
while (lambda_vector_first_nz (row, n, j + 1) < n)
{
int min_col = lambda_vector_min_nz (row, n, j);
lambda_matrix_col_exchange (temp, n, j, min_col);
lambda_matrix_col_exchange (inv, n, j, min_col);
for (i = j + 1; i < n; i++)
{
int factor;
factor = -1 * row[i];
if (row[j] != 1)
factor /= row[j];
lambda_matrix_col_add (temp, n, j, i, factor);
lambda_matrix_col_add (inv, n, j, i, factor);
}
}
}
/* Reduce TEMP from a lower triangular to the identity matrix. Also compute
the determinant, which now is simply the product of the elements on the
diagonal of TEMP. If one of these elements is 0, the matrix has 0 as an
eigenvalue so it is singular and hence not invertible. */
determinant = 1;
for (j = n - 1; j >= 0; j--)
{
int diagonal;
row = temp[j];
diagonal = row[j];
/* The matrix must not be singular. */
gcc_assert (diagonal);
determinant = determinant * diagonal;
/* If the diagonal is not 1, then multiply the each row by the
diagonal so that the middle number is now 1, rather than a
rational. */
if (diagonal != 1)
{
for (i = 0; i < j; i++)
lambda_matrix_col_mc (inv, n, i, diagonal);
for (i = j + 1; i < n; i++)
lambda_matrix_col_mc (inv, n, i, diagonal);
row[j] = diagonal = 1;
}
/* Sweep the lower triangle column wise. */
for (i = j - 1; i >= 0; i--)
{
if (row[i])
{
int factor = -row[i];
lambda_matrix_col_add (temp, n, j, i, factor);
lambda_matrix_col_add (inv, n, j, i, factor);
}
}
}
return determinant;
}
