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); }