void conjugate_gradient
(double **A, double *x, double *b, int n, double tol,
int max_iterations, bool ortho1) {
/* Solves Ax=b using Conjugate-Gradients method */
/* 'x' and 'b' are orthogonalized against 1 if 'ortho1=true' */
int i;
double alpha, beta, r_r, r_r_new, p_Ap;
double r[n];
double p[n];
double Ap[n];
double Ax[n];
double alphap[n];
double orth_b[n];
copy_vector(n, b, orth_b);
if (ortho1) {
orthog1(n, orth_b);
orthog1(n, x);
}
right_mult_with_vector_d(A, n, n, x, Ax);
vectors_subtraction(n, orth_b, Ax, r);
copy_vector(n, r, p);
r_r = vectors_inner_product(n, r, r);
for (i = 0; i < max_iterations && max_abs(n, r) > tol; i++) {
right_mult_with_vector_d(A, n, n, p, Ap);
p_Ap = vectors_inner_product(n, p, Ap);
if (p_Ap == 0) break;
alpha = r_r / p_Ap;
/* derive new x: */
vectors_scalar_mult(n, p, alpha, alphap);
vectors_addition(n, x, alphap, x);
/* compute values for next iteration: */
if (i < max_iterations - 1) { /* not last iteration */
vectors_scalar_mult(n, Ap, alpha, Ap);
vectors_subtraction(n, r, Ap, r); /* fast computation of r, the residual */
/* Alternaive accurate, but slow, computation of the residual - r */
/* right_mult_with_vector(A, n, x, Ax); */
/* vectors_subtraction(n,b,Ax,r); */
r_r_new = vectors_inner_product(n, r, r);
if (r_r == 0) exit(1);
beta = r_r_new / r_r;
r_r = r_r_new;
vectors_scalar_mult(n, p, beta, p);
vectors_addition(n, r, p, p);
}
}
}
bool
power_iteration(double **square_mat, int n, int neigs, double **eigs,
double *evals, bool initialize)
{
/* compute the 'neigs' top eigenvectors of 'square_mat' using power iteration */
int i, j;
double *tmp_vec = N_GNEW(n, double);
double *last_vec = N_GNEW(n, double);
double *curr_vector;
double len;
double angle;
double alpha;
int iteration = 0;
int largest_index;
double largest_eval;
int Max_iterations = 30 * n;
double tol = 1 - p_iteration_threshold;
if (neigs >= n) {
neigs = n;
}
for (i = 0; i < neigs; i++) {
curr_vector = eigs[i];
/* guess the i-th eigen vector */
choose:
if (initialize)
for (j = 0; j < n; j++)
curr_vector[j] = rand() % 100;
/* orthogonalize against higher eigenvectors */
for (j = 0; j < i; j++) {
alpha = -dot(eigs[j], 0, n - 1, curr_vector);
scadd(curr_vector, 0, n - 1, alpha, eigs[j]);
}
len = norm(curr_vector, 0, n - 1);
if (len < 1e-10) {
/* We have chosen a vector colinear with prvious ones */
goto choose;
}
vecscale(curr_vector, 0, n - 1, 1.0 / len, curr_vector);
iteration = 0;
do {
iteration++;
cpvec(last_vec, 0, n - 1, curr_vector);
right_mult_with_vector_d(square_mat, n, n, curr_vector,
tmp_vec);
cpvec(curr_vector, 0, n - 1, tmp_vec);
/* orthogonalize against higher eigenvectors */
for (j = 0; j < i; j++) {
alpha = -dot(eigs[j], 0, n - 1, curr_vector);
scadd(curr_vector, 0, n - 1, alpha, eigs[j]);
}
len = norm(curr_vector, 0, n - 1);
if (len < 1e-10 || iteration > Max_iterations) {
/* We have reached the null space (e.vec. associated with e.val. 0) */
goto exit;
}
vecscale(curr_vector, 0, n - 1, 1.0 / len, curr_vector);
angle = dot(curr_vector, 0, n - 1, last_vec);
} while (fabs(angle) < tol);
evals[i] = angle * len; /* this is the Rayleigh quotient (up to errors due to orthogonalization):
u*(A*u)/||A*u||)*||A*u||, where u=last_vec, and ||u||=1
*/
}
exit:
for (; i < neigs; i++) {
/* compute the smallest eigenvector, which are */
/* probably associated with eigenvalue 0 and for */
/* which power-iteration is dangerous */
curr_vector = eigs[i];
/* guess the i-th eigen vector */
for (j = 0; j < n; j++)
curr_vector[j] = rand() % 100;
/* orthogonalize against higher eigenvectors */
for (j = 0; j < i; j++) {
alpha = -dot(eigs[j], 0, n - 1, curr_vector);
scadd(curr_vector, 0, n - 1, alpha, eigs[j]);
}
len = norm(curr_vector, 0, n - 1);
vecscale(curr_vector, 0, n - 1, 1.0 / len, curr_vector);
evals[i] = 0;
}
/* sort vectors by their evals, for overcoming possible mis-convergence: */
for (i = 0; i < neigs - 1; i++) {
largest_index = i;
largest_eval = evals[largest_index];
for (j = i + 1; j < neigs; j++) {
if (largest_eval < evals[j]) {
largest_index = j;
largest_eval = evals[largest_index];
}
}
if (largest_index != i) { /* exchange eigenvectors: */
cpvec(tmp_vec, 0, n - 1, eigs[i]);
cpvec(eigs[i], 0, n - 1, eigs[largest_index]);
cpvec(eigs[largest_index], 0, n - 1, tmp_vec);
evals[largest_index] = evals[i];
evals[i] = largest_eval;
}
}
free(tmp_vec);
free(last_vec);
return (iteration <= Max_iterations);
}
