void
tridiag_eigenv(double *eig, double *a, double *b, int n)
{
gsl_matrix *A = gsl_matrix_calloc(n, n);
gsl_matrix_set (A, 0, 0, a[0]);
gsl_matrix_set (A, 0, 0+1, b[0]);
for(int i=1; i<n-1; i++)
{
gsl_matrix_set(A, i, i, a[i]);
gsl_matrix_set(A, i, i+1, b[i]);
gsl_matrix_set(A, i, i-1, b[i-1]);
}
gsl_matrix_set(A, n-1, n-1, a[n-1]);
gsl_matrix_set(A, n-1, n-1-1, b[n-1-1]);
gsl_vector *e = gsl_vector_alloc(n);
gsl_eigen_symm_workspace *w = gsl_eigen_symm_alloc(n);
gsl_eigen_symm(A, e, w);
gsl_eigen_symm_free(w);
gsl_matrix_free(A);
gsl_sort_vector(e);
for(int i=0; i<n; i++)
eig[i] = gsl_vector_get(e, i);
gsl_vector_free(e);
return;
}
void mcmclib_matrix_symm_eigenvalues(const gsl_matrix* A, gsl_vector* out) {
gsl_matrix* A1 = gsl_matrix_alloc(A->size1, A->size2);
gsl_matrix_memcpy(A1, A);
gsl_eigen_symm_workspace* w = gsl_eigen_symm_alloc (A1->size1);
gsl_eigen_symm(A1, out, w);
gsl_eigen_symm_free (w);
gsl_matrix_free(A1);
}
void
gsl_eigen_gensymm_free (gsl_eigen_gensymm_workspace * w)
{
if (w->symm_workspace_p)
gsl_eigen_symm_free(w->symm_workspace_p);
free(w);
} /* gsl_eigen_gensymm_free() */
void
gsl_eigen_gensymm_free (gsl_eigen_gensymm_workspace * w)
{
RETURN_IF_NULL (w);
if (w->symm_workspace_p)
gsl_eigen_symm_free(w->symm_workspace_p);
free(w);
} /* gsl_eigen_gensymm_free() */
void
test_eigen_symm_matrix(const gsl_matrix * m, size_t count,
const char * desc)
{
const size_t N = m->size1;
gsl_matrix * A = gsl_matrix_alloc(N, N);
gsl_vector * eval = gsl_vector_alloc(N);
gsl_vector * evalv = gsl_vector_alloc(N);
gsl_vector * x = gsl_vector_alloc(N);
gsl_vector * y = gsl_vector_alloc(N);
gsl_matrix * evec = gsl_matrix_alloc(N, N);
gsl_eigen_symm_workspace * w = gsl_eigen_symm_alloc(N);
gsl_eigen_symmv_workspace * wv = gsl_eigen_symmv_alloc(N);
gsl_matrix_memcpy(A, m);
gsl_eigen_symmv(A, evalv, evec, wv);
test_eigen_symm_results(m, evalv, evec, count, desc, "unsorted");
gsl_matrix_memcpy(A, m);
gsl_eigen_symm(A, eval, w);
/* sort eval and evalv */
gsl_vector_memcpy(x, eval);
gsl_vector_memcpy(y, evalv);
gsl_sort_vector(x);
gsl_sort_vector(y);
test_eigenvalues_real(y, x, desc, "unsorted");
gsl_eigen_symmv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_ASC);
test_eigen_symm_results(m, evalv, evec, count, desc, "val/asc");
gsl_eigen_symmv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_DESC);
test_eigen_symm_results(m, evalv, evec, count, desc, "val/desc");
gsl_eigen_symmv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_ASC);
test_eigen_symm_results(m, evalv, evec, count, desc, "abs/asc");
gsl_eigen_symmv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_DESC);
test_eigen_symm_results(m, evalv, evec, count, desc, "abs/desc");
gsl_matrix_free(A);
gsl_vector_free(eval);
gsl_vector_free(evalv);
gsl_vector_free(x);
gsl_vector_free(y);
gsl_matrix_free(evec);
gsl_eigen_symm_free(w);
gsl_eigen_symmv_free(wv);
} /* test_eigen_symm_matrix() */
Matrix eigenValuesRealSym(const Matrix &m){
// check if m is square
assert(m.getM() == m.getN());
gsl_matrix* m_gsl = toGSL(m);
gsl_eigen_symm_workspace* w = gsl_eigen_symm_alloc (m.getM());
gsl_vector *eval = gsl_vector_alloc (m.getM());
gsl_eigen_symm (m_gsl, eval, w);
gsl_eigen_symm_free (w);
// the multiplication with -1 causes a descending ordering
Matrix m_eval = fromGSL(eval) * -1 ;
m_eval.toSort();
return m_eval * -1;
}
void
lls_free(lls_workspace *w)
{
if (w->ATA)
gsl_matrix_free(w->ATA);
if (w->ATb)
gsl_vector_free(w->ATb);
if (w->work_A)
gsl_matrix_free(w->work_A);
if (w->work_b)
gsl_vector_free(w->work_b);
if (w->c)
gsl_vector_free(w->c);
if (w->AF)
gsl_matrix_free(w->AF);
if (w->S)
gsl_vector_free(w->S);
if (w->r)
gsl_vector_free(w->r);
if (w->w_robust)
gsl_vector_free(w->w_robust);
if (w->eigen_p)
gsl_eigen_symm_free(w->eigen_p);
if (w->eval)
gsl_vector_free(w->eval);
if (w->robust_workspace_p)
gsl_multifit_robust_free(w->robust_workspace_p);
free(w);
} /* lls_free() */
int check_and_fix_covmat(gsl_matrix *covmat) {
int i, s, test;
double eigenval_i;
gsl_vector_view diag;
int nelt;
gsl_matrix *mat;
gsl_vector *eigenval;
gsl_vector *eigenval_temp;
gsl_eigen_symm_workspace *wval;
gsl_eigen_symmv_workspace *wvec;
gsl_matrix *Q;
gsl_matrix *Qinv;
gsl_matrix *Lambda;
gsl_matrix *temp;
gsl_permutation *pp;
nelt = covmat->size1;
mat=gsl_matrix_alloc(nelt,nelt);
wval = gsl_eigen_symm_alloc(nelt);
wvec = gsl_eigen_symmv_alloc(nelt);
eigenval = gsl_vector_alloc(nelt);
// don't destroy the input matrix!
gsl_matrix_memcpy(mat, covmat);
// calculate eigenvalues...
gsl_eigen_symm(mat, eigenval, wval);
// test if the eigenvalues are negative...
test = 0;
for (i=0;i<nelt;i++) {
eigenval_i = gsl_vector_get(eigenval,i);
if (eigenval_i < MIN_EIGENVAL) {
test = 1;
gsl_vector_set(eigenval,i,MIN_EIGENVAL);
}
}
if (test) {
// initialize
Q=gsl_matrix_alloc(nelt,nelt);
Qinv=gsl_matrix_alloc(nelt,nelt);
Lambda=gsl_matrix_alloc(nelt,nelt);
temp=gsl_matrix_alloc(nelt,nelt);
eigenval_temp=gsl_vector_alloc(nelt);
pp=gsl_permutation_alloc(nelt);
// reset the matrix
gsl_matrix_memcpy(mat, covmat);
// calculate eigenvalues and eigenvector matrix Q
gsl_eigen_symmv(mat, eigenval_temp, Q, wvec);
// invert eigenvector matrix Q-> Qinv (leaving Q in place)
gsl_matrix_memcpy(temp,Q);
gsl_linalg_LU_decomp(temp, pp, &s);
gsl_linalg_LU_invert(temp, pp, Qinv);
// create a diagonal matrix Lambda
diag = gsl_matrix_diagonal(Lambda);
gsl_matrix_set_zero(Lambda);
gsl_vector_memcpy(&diag.vector, eigenval);
// do the multiplication
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, Q, Lambda, 0.0, temp);
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, temp, Qinv, 0.0, covmat);
gsl_matrix_free(Q);
gsl_matrix_free(Qinv);
gsl_matrix_free(Lambda);
gsl_matrix_free(temp);
gsl_vector_free(eigenval_temp);
gsl_permutation_free(pp);
}
gsl_matrix_free(mat);
gsl_vector_free(eigenval);
gsl_eigen_symm_free(wval);
gsl_eigen_symmv_free(wvec);
return 0;
}
int main(int argc, char * argv[])
{
int num,i,*states,num_e,j,k;
double *entry, *dos_vec, *eval_vec;
double coef;
char tmpc;
gsl_vector *eval;
gsl_matrix_view m;
gsl_eigen_symm_workspace *w;
gsl_matrix_complex * matrix2;
gsl_complex z;
gsl_permutation * p;
char name[25];
FILE *out;
if ((out = fopen(argv[1],"r")) != NULL)
{
num = 0;
printf("reading from file: %s....\n",argv[1]);
while(fscanf(out,"%lf",&coef) != EOF) num++;
if (modf(sqrt(num),&coef) != 0)
{
printf("not a square matrix!\n\n");
return 1;
}
//printf("%d\n",num);
fseek(out,0,SEEK_SET);
num = sqrt(num);
entry = (double *)malloc(sizeof(double) * num * num);
i = 0;
while (i < (num * num))
{
*(entry + i) = 0;
i++;
}
i = 0;
printf("loading matrix into memory...\n");
while(fscanf(out,"%lf",&coef) != EOF)
{
*(entry + i) = coef;
printf("entry %d = %g\n",i + 1,coef);
i++;
}
flags += NUMPRINT;
flags += READFROMFILE;
}
if (argc < 6 && (flags & READFROMFILE) == 0)
{
printf("usage: no. of layers, slope of cone/no. of atoms per layer, on-site energy, hopping parameter, model, (option)\n");
printf("\n Models are:\n1: Nanotube, square lattice\n2: Nanotube, hex lattice (armchair)\n");
printf("3: Nanohorn, square lattice\n4: Nanohorn hex lattice\n5: Nanotube, hex lattice (zig-zag)\n");
printf("\nOptions are: p - print symbolically\n n - print numerically\n\n");
return 1;
}
else if ((flags & READFROMFILE) != 0)
{
}
else
{
num = atoi(argv[1]);
Epsilon = atol(argv[3]);
Gamma = atol(argv[4]);
switch(atoi(argv[5]))
{
case 1: flags = flags + CNT_SQUARE;
Alpha = atoi(argv[2]);
num *= Alpha;
entry = (double *)malloc(sizeof(double) * num * num);
break;
case 2: flags = flags + CNT_HEX_ARM;
Alpha = atoi(argv[2]);
i = Alpha;
if ((i % 2) != 0)
{
printf("no. of atoms per layer must be even, changing to %d\n",i + 1);
Alpha += 1;
}
num *= (Alpha);
entry = (double *)malloc(sizeof(double) * num * num);
break;
case 3: flags = flags + HORN_SQUARE;
i = 1;
num_e = 0;
while (i <= num)
{
num_e += i;
i++;
}
num = num_e;
entry = (double *)malloc(sizeof(double) * num * num);
break;
case 4: flags = flags + HORN_HEX;
num = 0;
entry = NULL;
break;
case 5: flags = flags + CNT_HEX_ZIG;
Alpha = atoi(argv[2]);
i = Alpha;
while ((i % 4) != 0)
{
i++;
}
Alpha = i;
num *= Alpha;
entry = (double *)malloc(sizeof(double) * num * num);
break;
default: printf("No valid model choice!\n");
return 1;
break;
}
i = 0;
while (i < (num * num))
{
*(entry + i) = 0;
i++;
}
printf("Alpha = %g\n",Alpha);
}
printf("%d atoms\n",num);
if (argc > 6)
{
if (strcmp("p\0",argv[6]) == 0)
{
//printf("print");
flags = flags + PRINT;
}
if (strcmp("n\0", argv[6]) == 0)
{
flags = flags + NUMPRINT;
}
}
eval = gsl_vector_alloc(num);
//printf("flags %d\n",flags);
//k = (flags & PRINT);
//printf("print ? %d\n",k);
//printf("%lf",Alpha);
//printf("%d",num);
if (entry == NULL)
{
printf("could not allocate memory\n");
return 1;
}
i = 0;
if ((flags & READFROMFILE) == 0)
{
printf("Populating Matrix...\n");
PopulateMatrix(entry,num);
out = fopen("matrix","w");
i = 0;
while (i < (num * num))
{
fprintf(out,"%3.5lf ",*(entry + i));
if (((i + 1) % num) == 0) fprintf(out,"\n");
i++;
}
fclose(out);
}
else
{
}
printf("Printing Matrix\n");
PrintMatrix(entry,num);
//CalcEigenvalues(entry,num,eval);
//Eigenvalue Calculation
m = gsl_matrix_view_array (entry,num,num);
//printf("87\n");
w = gsl_eigen_symm_alloc (num);
//printf("89\n");
printf("Solving Eigenvalue equation....\n");
if(gsl_eigen_symm (&m.matrix, eval, w))
{
printf("an error occurred solving the eigenvalue equation\n");
return 1;
}
//printf("\nworkspace location = %#x",w);
gsl_eigen_symm_free(w);
printf("\n\n");
//if (flags & NUMPRINT != 0 || flags & PRINT != 0)
printf("Eigenvalues found. ");
eval_vec = malloc(sizeof(double) * num);
i = 0;
while (i < num)
{
*(eval_vec + i) = gsl_vector_get(eval,i);
i++;
}
gsl_vector_free(eval);
tmpc = 0;
printf("Ordering Eigenvalues...\n");
qsort(eval_vec,num,sizeof(double),comparedouble);
division = ((*(eval_vec + num - 1) - *eval_vec) / num) * 10 * INTERVAL;
num_e = ((*(eval_vec + num - 1) - *eval_vec))/ division;
num_e++; //just in case
while ((flags & FINISHED) == 0)
{
if (tmpc != -1) printf("(s)ave in file, (q)uit and discard, (p)rint (!), (d)ensity of states: ");
scanf("%c",&tmpc);
if (tmpc == 'p' || tmpc == 'P')
{
i = 0;
while (i < num)
{
printf("Eigenvalue %d\t: %g\n",(i + 1),*(eval_vec + i));
i++;
}
printf("\n");
tmpc = -1;
}
else if (tmpc == 'q' || tmpc == 'Q')
{
printf("\nexiting...\n\n");
flags += FINISHED;
}
else if (tmpc == 'd' || tmpc == 'D')
{
tmpc = 0;
dos_vec = malloc(sizeof(double) * num_e);
states = malloc(sizeof(int) * num_e);
printf("\nCalculating density of states...\n");
Calculate(eval_vec,num,dos_vec,states);
i = 0;
printf("\n");
out = fopen("dostube","w");
while (i < num_e && *(states + i) >= 0)
{
printf("Energy: % .5lf\tNo. of states: %d\n",*(dos_vec + i),*(states + i));
fprintf(out,"% .5lf\t%d\n",*(dos_vec + i),*(states + i));
i++;
}
num_e = i;
fclose(out);
flags += FINISHED;
flags += DOS;
}
else if (tmpc == -1) //WHY?!!
{
tmpc = 0;
}
else if (tmpc == 's' || tmpc == 'S') //broken for some reason
{
printf("\nchoose filename: ");
scanf("%s",name);
//printf("%s",name);
out = fopen(name,"r");
if (out != NULL)
{
printf("File already exists!\n");
fclose(out);
}
else
{
fclose(out);
out = fopen(name,"w");
printf("Writing to file: %s",name);
i = 0;
while (i < num)
{
fprintf(out,"Eigenvalue %d\t: %g\n",(i + 1),*(eval_vec + i));
i++;
}
fclose(out);
tmpc = -1;
}
}
else
{
printf("unrecognised option!\n");
}
}
if ((flags & DOS) != 0)
{
while (j < num_e)
{
matrix2 = gsl_matrix_complex_alloc(sizeof(gsl_complex) * num,sizeof(gsl_complex) * num);
i = 0;
gsl_matrix_complex_set_identity(matrix2);
z.dat[0] = *(dos_vec + j);
z.dat[1] = 0.0001;
gsl_matrix_complex_scale(matrix2,z);
while (i < num)
{
k = 0;
while(k < num)
{
z = gsl_matrix_complex_get(matrix2,i,k);
z.dat[0] -= *(entry + i + (k * num));
gsl_matrix_complex_set(matrix2,i,k,z);
k++;
}
i++;
}
out = fopen("matrix","w");
gsl_matrix_complex_fprintf(out,matrix2,"% 2.2lf");
fclose(out);
free(entry);
}
}
//printf("\neval location = %#x",eval);
return 0;
}
void eig_end ()
{
if (eig_work) gsl_eigen_symm_free (eig_work);
if (eigv_work) gsl_eigen_symmv_free (eigv_work);
gsl_vector_free (eigen_values);
}
