//Computes the second-largest eigenvalue of a matrix A.
//Uses the power method on A^2.

#include <math.h>
#include "defs.h"

#define S (N*L)  /* dimension of the lift matrix is N*L by K */
typedef real vector[S];

#define EPSILON (1E-10)

//First, some functions:

/* compute y = A*x */
inline void matrix_vect_mult (lift_graph H, vector x, vector y){
  index i,j;

  for(i=0; i<S; i++) {
    y[i] = 0.0;
    for(j=0; j<K; j++){
      y[i]+=x[H[i][j]];
    }
  }
}

/* compute ||x|| */
inline real norm (vector x){
  index i;
  real s=0.0;
  for (i=0; i<S; i++)
    s+= x[i]*x[i];

  return sqrt(s);
}


//Now the power method: 

real symm_gap (lift_graph H){
  vector x,y,z;
  real s,t,u,l;
  index i;


  /* initial guess: z[i] = i */
  for (i=0; i<S; i++)
    z[i] = i - ((S-1)/2.0);  /* make orthogonal to the constant vector, v */
                                   /* that is, v[i] = c for all i */

  s = norm(z); 

  do {
    for (i=0; i<S; i++)
      x[i] = z[i]/s; /* normalize z */

    matrix_vect_mult(H, x, y);
    matrix_vect_mult(H, y, z);  /* new z = A^2*x */
   

    s=0.0;
    for(i=0; i<S; i++)
      s+=z[i];         /* compute <z,1> */

    s /= S; /* s is now the average of the entries of z */

    t=0.0; l=0.0;
    for(i=0; i<S; i++){
      z[i] -= s;       /* re-orthogonalize the new z */
      l += z[i]*x[i];  /* l = inner product of x and z */
    }

    s = norm(z);  /* put s back to norm(z) */

    t = 0.0;
    for (i=0; i<S; i++){
      u = (z[i] - l*x[i]);
      t += u*u;
    }
    /* if z - l*x = A*x - l*x is small, stop and accept l = lambda_1*/
  } while (t > EPSILON*s*s);

  return sqrt(l); /* since we used A^2 */
}