EigenCovariance3::EigenCovariance3(const Covariance3& cov) { static gsl_eigen_symmv_workspace * m_eigenspace = NULL; static gsl_matrix * m_cmat = NULL; static gsl_matrix * m_evec = NULL; static gsl_vector * m_eval = NULL; static gsl_vector * m_noise = NULL; static gsl_vector * m_pnoise = NULL; if (m_eigenspace == NULL) { m_eigenspace = gsl_eigen_symmv_alloc(3); m_cmat = gsl_matrix_alloc(3, 3); m_evec = gsl_matrix_alloc(3, 3); m_eval = gsl_vector_alloc(3); m_noise = gsl_vector_alloc(3); m_pnoise = gsl_vector_alloc(3); } gsl_matrix_set(m_cmat, 0, 0, cov.xx); gsl_matrix_set(m_cmat, 0, 1, cov.xy); gsl_matrix_set(m_cmat, 0, 2, cov.xt); gsl_matrix_set(m_cmat, 1, 0, cov.xy); gsl_matrix_set(m_cmat, 1, 1, cov.yy); gsl_matrix_set(m_cmat, 1, 2, cov.yt); gsl_matrix_set(m_cmat, 2, 0, cov.xt); gsl_matrix_set(m_cmat, 2, 1, cov.yt); gsl_matrix_set(m_cmat, 2, 2, cov.tt); gsl_eigen_symmv(m_cmat, m_eval, m_evec, m_eigenspace); for (int i = 0; i<3; i++) { eval[i] = gsl_vector_get(m_eval, i); for (int j = 0; j<3; j++) evec[i][j] = gsl_matrix_get(m_evec, i, j); } }
void eigensolve(vector vec1, vector vec2, vector vec3, real *vals, matrix symmat) { int i, j; double data[9]; gsl_matrix_view mat; gsl_vector_view vec; gsl_vector *eigval = gsl_vector_alloc(3); gsl_matrix *eigvec = gsl_matrix_alloc(3, 3); gsl_eigen_symmv_workspace *work = gsl_eigen_symmv_alloc(3); for (i = 0; i < 3; i++) for (j = 0; j < 3; j++) data[3*i + j] = symmat[i][j]; mat = gsl_matrix_view_array(data, 3, 3); gsl_eigen_symmv(&mat.matrix, eigval, eigvec, work); gsl_eigen_symmv_free(work); gsl_eigen_symmv_sort(eigval, eigvec, GSL_EIGEN_SORT_VAL_DESC); for (i = 0; i < 3; i++) vals[i] = gsl_vector_get(eigval, i); vec = gsl_matrix_column(eigvec, 0); for (i = 0; i < 3; i++) vec1[i] = gsl_vector_get(&vec.vector, i); vec = gsl_matrix_column(eigvec, 1); for (i = 0; i < 3; i++) vec2[i] = gsl_vector_get(&vec.vector, i); vec = gsl_matrix_column(eigvec, 2); for (i = 0; i < 3; i++) vec3[i] = gsl_vector_get(&vec.vector, i); gsl_vector_free(eigval); gsl_matrix_free(eigvec); }
gsl_eigen_gensymmv_workspace * gsl_eigen_gensymmv_alloc(const size_t n) { gsl_eigen_gensymmv_workspace *w; if (n == 0) { GSL_ERROR_NULL ("matrix dimension must be positive integer", GSL_EINVAL); } w = (gsl_eigen_gensymmv_workspace *) calloc (1, sizeof (gsl_eigen_gensymmv_workspace)); if (w == 0) { GSL_ERROR_NULL ("failed to allocate space for workspace", GSL_ENOMEM); } w->size = n; w->symmv_workspace_p = gsl_eigen_symmv_alloc(n); if (!w->symmv_workspace_p) { gsl_eigen_gensymmv_free(w); GSL_ERROR_NULL("failed to allocate space for symmv workspace", GSL_ENOMEM); } return (w); } /* gsl_eigen_gensymmv_alloc() */
void egsl_symm_eig(val v, double* eigenvalues, val* eigenvectors) { gsl_matrix *m = egsl_gslm(v); size_t N = m->size1; /* Check for v to be square */ gsl_matrix *A = gsl_matrix_alloc(N,N); gsl_matrix_memcpy(A, m); gsl_vector *eval = gsl_vector_alloc(N); gsl_matrix *evec = gsl_matrix_alloc(N,N); gsl_eigen_symmv_workspace * ws = gsl_eigen_symmv_alloc(N); gsl_eigen_symmv(A, eval, evec, ws); gsl_eigen_symmv_free(ws); gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_VAL_DESC); size_t j; for(j=0;j<N;j++) { eigenvalues[j] = gsl_vector_get(eval, j); eigenvectors[j] = egsl_alloc(N,1); size_t i; for(i=0;i<N;i++) *egsl_atmp(eigenvectors[j],i,0) = gsl_matrix_get(evec,i,j); } gsl_vector_free(eval); gsl_matrix_free(evec); gsl_matrix_free(A); }
int main(int argc, char *argv[]) { const size_t NDIM = 3; double data[NDIM * NDIM]; gsl_matrix_view m = gsl_matrix_view_array(data, NDIM, NDIM); gsl_vector *eval = gsl_vector_alloc (NDIM); gsl_matrix *evec = gsl_matrix_alloc (NDIM, NDIM); gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (NDIM); gsl_eigen_symmv (&m.matrix, eval, evec, w); gsl_eigen_symmv_free (w); //Sort Eigenvalues in ascending order gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_VAL_ASC); // for (size_t i = 0; i < NDIM; i++) // { // retVal.EigenVal[i] = gsl_vector_get(eval, i) / range->size(); // // gsl_vector_view evec_i // = gsl_matrix_column (evec, i); // // //EigenVec Components // for (size_t j = 0; j < NDIM; j++) // retVal.EigenVec[i][j] = gsl_vector_get(&evec_i.vector, j); // } //Cleanup GSL gsl_vector_free (eval); gsl_matrix_free (evec); }
void pca(double sample[][NUM_SAMPLE]) { unsigned int n, d, i, j; double s, avg[DIM], stdev[DIM], pcs[DIM]; gsl_vector *const eigenvals = gsl_vector_alloc(DIM); gsl_matrix *const C = gsl_matrix_alloc(DIM, DIM), *const eigenvecs = gsl_matrix_alloc(DIM, DIM); gsl_eigen_symmv_workspace *const w = gsl_eigen_symmv_alloc(DIM); for (d = 0; d < DIM; ++d) avg[d] = 0, stdev[d] = 0; for (d = 0; d < DIM; ++d) for (n = 0; n < NUM_SAMPLE; ++n) avg[d] += sample[d][n] / NUM_SAMPLE; for (d = 0; d < DIM; ++d) for (n = 0; n < NUM_SAMPLE; ++n) { sample[d][n] -= avg[d]; stdev[d] += sample[d][n] * sample[d][n] / NUM_SAMPLE; } for (d = 0; d < DIM; ++d) stdev[d] = sqrt(stdev[d]); for (d = 0; d < DIM; ++d) printf("stdev[%u] == %f\n", d, stdev[d]); for (d = 0; d < DIM; ++d) for (n = 0; n < NUM_SAMPLE; ++n) sample[d][n] /= stdev[d]; for (i = 0; i < DIM; ++i) for (j = 0; j < DIM; ++j) { for (s = 0, n = 0; n < NUM_SAMPLE; ++n) s += sample[i][n] * sample[j][n] / NUM_SAMPLE; gsl_matrix_set(C, i, j, s); } gsl_eigen_symmv(C, eigenvals, eigenvecs, w); for (i = 0; i < DIM; ++i) pcs[i] = gsl_vector_get(eigenvals, i); qsort(pcs, DIM, sizeof(double), comp); for (i = 0; i < DIM; ++i) printf("%f ", pcs[i]); printf("\n"); gsl_vector_free(eigenvals); gsl_matrix_free(C); gsl_matrix_free(eigenvecs); gsl_eigen_symmv_free(w); }
/* compute evals and evecs of symmetric matrix */ void compute_evals_and_evecs_of_symm_matrix(gsl_matrix *M, gsl_vector *eval, gsl_matrix *evec){ gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (M->size1); gsl_eigen_symmv (M, eval, evec, w); gsl_eigen_symmv_free(w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); }
void eigen(double * dataPtr, int n, gsl_vector *eval, gsl_matrix *evec) // dataPtr points to n*n matrix, contigues storage { gsl_matrix_view m = gsl_matrix_view_array (dataPtr, n, n); gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (n); gsl_eigen_symmv (&m.matrix, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); } // eigen
void gsl_eig(gsl_matrix *sym, gsl_vector *eval, gsl_matrix *evec ,size_t NCOMP){ //Compute eigen values with GSL size_t NSUB = sym->size1; gsl_eigen_symmv_workspace *w = gsl_eigen_symmv_alloc(NSUB); gsl_eigen_symmv(sym, eval, evec, w); gsl_eigen_symmv_free(w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_DESC); gsl_matrix_view temp = gsl_matrix_submatrix(sym, 0,0 , NSUB, NCOMP); gsl_matrix_memcpy(evec,&temp.matrix); }
int main (){ int N=4; int S=(int)(((double)1/12)*N*(N+1)*(2*N+1)+((double)1/4)*N*(N+1)); double t=sqrt(2); double U=0; int Ar[(int)pow(S,2)][2]; double H[]={t,1}; int e=1; gsl_eigen_symmv_workspace *W=gsl_eigen_symmv_alloc(S); gsl_vector *evals = gsl_vector_alloc(S); gsl_matrix *evecs = gsl_matrix_alloc(S,S); gsl_matrix *M=gsl_matrix_alloc(S,S); for(int i=0;i<S;i++){ xhop_l1(i,M,N,t,H); H[0]=t;H[1]=1; xhop_l2(i,M,N,t,H); H[0]=t;H[1]=1; xhop_r1(i,M,N,t,H); H[0]=t;H[1]=1; xhop_r2(i,M,N,t,H); H[0]=t;H[1]=1; yhop_l1(i,M,N,t,H); H[0]=t;H[1]=1; yhop_l2(i,M,N,t,H); H[0]=t;H[1]=1; yhop_r1(i,M,N,t,H); H[0]=t;H[1]=1; yhop_r2(i,M,N,t,H); H[0]=t;H[1]=1; zhop_l1(i,M,N,t,H); H[0]=t;H[1]=1; zhop_l2(i,M,N,t,H); H[0]=t;H[1]=1; zhop_r1(i,M,N,t,H); H[0]=t;H[1]=1; zhop_r2(i,M,N,t,H); H[0]=t;H[1]=1; onsite(i,M,N,U); } for(int i=0;i<S;i++){ for(int j=0;j<S;j++) printf("%7g ", gsl_matrix_get(M,i,j)); printf("\n\n"); } return 0; }
void eig_init (Matrix& src, bool compute_eigenvectors) { if (src.rows() != src.columns()) throw Exception ("can't calculate eigenvalues for non-square matrices"); eigen_values = gsl_vector_alloc(src.rows()); eig_work = NULL; eigv_work = NULL; if (compute_eigenvectors) eigv_work = gsl_eigen_symmv_alloc (src.rows()); else eig_work = gsl_eigen_symm_alloc (src.rows()); }
/// Calculate the eigensystem of a symmetric matrix /// @param eigenValues :: Output variable that receives the eigenvalues of this /// matrix. /// @param eigenVectors :: Output variable that receives the eigenvectors of /// this matrix. void GSLMatrix::eigenSystem(GSLVector &eigenValues, GSLMatrix &eigenVectors) { size_t n = size1(); if (n != size2()) { throw std::runtime_error("Matrix eigenSystem: the matrix must be square."); } eigenValues.resize(n); eigenVectors.resize(n, n); auto workspace = gsl_eigen_symmv_alloc(n); gsl_eigen_symmv(gsl(), eigenValues.gsl(), eigenVectors.gsl(), workspace); gsl_eigen_symmv_free(workspace); }
void sym_eigen(gsl_matrix* m, gsl_vector* vals, gsl_matrix* vects) { gsl_eigen_symmv_workspace* wk; gsl_matrix* mcpy; mcpy = gsl_matrix_alloc(m->size1, m->size2); wk = gsl_eigen_symmv_alloc(m->size1); gsl_matrix_memcpy(mcpy, m); gsl_eigen_symmv(mcpy, vals, vects, wk); gsl_eigen_symmv_free(wk); gsl_matrix_free(mcpy); }
int get_eigen (gsl_matrix* m,gsl_vector* eval, gsl_matrix* evec, int n) { gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (n); gsl_eigen_symmv (m, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); return 0; }
/******************************************************************************* * void matrix_eig(data_t *out_eig_vect, data_t*out_eig_vals, data_t* matrix, int rows, int cols); * Get eigenvalues and eigenvectors of symmetric matrix * NOTE: ONLY SYMMETRIC MATRICIES ATM *******************************************************************************/ void m_eigenvalues_eigenvectors (matrix_t *M, matrix_t **p_eigenvalues, matrix_t **p_eigenvectors) { gsl_matrix * A = gsl_matrix_alloc (M->numRows, M->numCols); gsl_matrix * gslEigenvectors = gsl_matrix_alloc (M->numRows, M->numCols); gsl_vector * gslEigenvalues = gsl_vector_alloc (M->numRows); precision val; int i, j; // Copy M into A for (i = 0; i < M->numRows; i++) { for (j = 0; j < M->numCols; j++) { val = m_getelem(M, i, j); gsl_matrix_set (A, i, j, val); } } // Compute the Eigenvalues using the GSL library // Allocate workspace gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (M->numRows); gsl_eigen_symmv (A, gslEigenvalues, gslEigenvectors, w); // ******************************************************** // COMMENT // We might need to normalize the eigenvectors here or something // to match matlab eigenvectors, they don't HAVE to to match but // its at least something to keep in mind // ******************************************************** matrix_t *eigenvalues = m_initialize (UNDEFINED, gslEigenvalues->size, 1); matrix_t *eigenvectors = m_initialize (UNDEFINED, gslEigenvectors->size1, gslEigenvectors->size2); // Copy the eigenvalues into a column matrix for (i = 0; i < gslEigenvalues->size; i++) { val = gsl_vector_get (gslEigenvalues, i); m_setelem(val, eigenvalues, i, 0); } // Copy the eigenvectors into a regular matrix for (i = 0; i < gslEigenvectors->size1; i++) { for (j = 0; j < gslEigenvectors->size2; j++) { val = gsl_matrix_get (gslEigenvectors, i, j); m_setelem(val, eigenvectors, i, j); } } gsl_eigen_symmv_free (w); gsl_matrix_free (gslEigenvectors); gsl_matrix_free (A); gsl_vector_free (gslEigenvalues); *p_eigenvectors = eigenvectors; *p_eigenvalues = eigenvalues; }
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() */
double ldmvnorm(const int n, const gsl_vector *x, const gsl_vector *mean, const gsl_matrix *var){ /* log-multivariate normal density function */ /* * n dimension of the random vetor * mean vector of means of size n * var variance matrix of dimension n x n */ int s; double ax,ay; gsl_vector *ym, *xm; gsl_matrix *work = gsl_matrix_alloc(n,n), *winv = gsl_matrix_alloc(n,n); #ifdef PRINTSTIFF /* Print Stiffness indicator S=max(eigen)/min(eigen)*/ gsl_vector *eval = gsl_vector_alloc (n); gsl_matrix *evec = gsl_matrix_alloc (n, n); gsl_matrix_memcpy(work,var); gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc(n); gsl_eigen_symmv (work, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); printf("%f ", gsl_vector_get(eval,n-1) / gsl_vector_get(eval,0)); gsl_vector_free(eval); gsl_matrix_free(evec); #endif gsl_permutation *p = gsl_permutation_alloc(n); gsl_matrix_memcpy( work, var ); gsl_linalg_LU_decomp( work, p, &s ); gsl_linalg_LU_invert( work, p, winv ); ax = gsl_linalg_LU_det( work, s ); gsl_matrix_free( work ); gsl_permutation_free( p ); xm = gsl_vector_alloc(n); gsl_vector_memcpy( xm, x); gsl_vector_sub( xm, mean ); ym = gsl_vector_alloc(n); gsl_blas_dsymv(CblasUpper,1.0,winv,xm,0.0,ym); gsl_matrix_free( winv ); gsl_blas_ddot( xm, ym, &ay); gsl_vector_free(xm); gsl_vector_free(ym); /* * ay = exp(-0.5*ay)/sqrt( pow((2*M_PI),n)*ax ); */ ay = -0.5*( ay + n*log(2*M_PI) + log(ax) ); return ay; }
int semirmvnorm(const gsl_rng *rnd, const unsigned int n, const gsl_matrix *Sigma, gsl_vector *randeffect) { unsigned int k, r=0; double lambda; gsl_matrix *work = gsl_matrix_alloc(n,n); gsl_matrix_memcpy(work, Sigma); // replace cholesky with eigen decomposition gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (n); gsl_vector *eval=gsl_vector_alloc (n); gsl_matrix *evec=gsl_matrix_alloc (n, n); // work = evec*diag(eval)*t(evec) gsl_eigen_symmv (work, eval, evec, w); // displayvector (eval, "eigen values of work"); // displaymatrix (evec, "eigen vector of work"); for (k=0; k<n; k++) { gsl_vector_view evec_i=gsl_matrix_column(evec, k); lambda=gsl_vector_get(eval, k); if (lambda>10e-10){ // non-zero variables // U = t(eval(r)*evec(:, r)) gsl_vector_scale (&evec_i.vector, sqrt(lambda)); // copy U to work gsl_matrix_set_col(work, r, &evec_i.vector); r++; } } // printf("r=%d.\n", r); gsl_matrix_view U=gsl_matrix_submatrix (work, 0, 0, n, r); // displaymatrix (&U.matrix, "partial eigen vectors"); // generate standard normal vector gsl_vector *z=gsl_vector_alloc(r); for(k=0; k<r; k++) gsl_vector_set( z, k, gsl_ran_ugaussian(rnd) ); // displayvector (z, "z"); // X_i = mu_i + t(U)*z gsl_blas_dgemv (CblasNoTrans, 1.0, &U.matrix, z, 0.0, randeffect); // displayvector (randeffect, "randeffect"); gsl_matrix_free(work); gsl_eigen_symmv_free(w); gsl_matrix_free(evec); gsl_vector_free(eval); gsl_vector_free(z); return 0; }
// Find B s.t. B B^T = A. This is useful for generating vectors from a multivariate normal distribution. void sqrt_matrix(gsl_matrix* A, gsl_matrix* sqrt_A, gsl_eigen_symmv_workspace* esv, gsl_vector *eival, gsl_matrix *eivec, gsl_matrix* sqrt_eival) { size_t N = A->size1; assert(A->size2 == N); // Allocate workspaces if none are provided bool del_esv = false; if(esv == NULL) { esv = gsl_eigen_symmv_alloc(N); del_esv = true; } bool del_eival = false; if(eival == NULL) { eival = gsl_vector_alloc(N); del_eival = true; } bool del_eivec = false; if(eivec == NULL) { eivec = gsl_matrix_alloc(N, N); del_eival = true; } bool del_sqrt_eival = false; if(sqrt_eival == NULL) { sqrt_eival = gsl_matrix_calloc(N, N); del_sqrt_eival = true; } else { assert(sqrt_eival->size1 == N); assert(sqrt_eival->size2 == N); gsl_matrix_set_zero(sqrt_eival); } if(sqrt_A == NULL) { sqrt_A = A; } else { assert(sqrt_A->size1 == N); assert(sqrt_A->size2 == N); gsl_matrix_memcpy(sqrt_A, A); } // Calculate the eigendecomposition of the covariance matrix gsl_eigen_symmv(sqrt_A, eival, eivec, esv); double tmp; for(size_t i=0; i<N; i++) { tmp = gsl_vector_get(eival, i); gsl_matrix_set(sqrt_eival, i, i, sqrt(fabs(tmp))); if(tmp < 0.) { for(size_t j=0; j<N; j++) { gsl_matrix_set(eivec, j, i, -gsl_matrix_get(eivec, j, i)); } } } gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1., eivec, sqrt_eival, 0., sqrt_A); // Free workspaces if none were provided if(del_sqrt_eival) { gsl_matrix_free(sqrt_eival); } if(del_esv) { gsl_eigen_symmv_free(esv); } if(del_eivec) { gsl_matrix_free(eivec); } if(del_eival) { gsl_vector_free(eival); } }
bool eigenValuesVectorsRealSym(const Matrix &m, Matrix& eigenvalues, Matrix& eigenvectors){ // check if m is square assert(m.getM() == m.getN()); gsl_matrix* m_gsl = toGSL(m); gsl_eigen_symmv_workspace* w = gsl_eigen_symmv_alloc (m.getM()); gsl_vector *eval = gsl_vector_alloc (m.getM()); gsl_matrix *evec = gsl_matrix_alloc (m.getM(), m.getM()); gsl_eigen_symmv (m_gsl, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_DESC); eigenvalues = fromGSL(eval); eigenvectors = fromGSL(evec); return true; }
// Same as above, but allocates and de-allocates worskspaces internally void sqrt_matrix(gsl_matrix* A, gsl_matrix* sqrt_A) { size_t N = A->size1; // Allocate workspaces gsl_eigen_symmv_workspace* esv = gsl_eigen_symmv_alloc(N); gsl_vector *eival = gsl_vector_alloc(N); gsl_matrix *eivec = gsl_matrix_alloc(N, N); gsl_matrix* sqrt_eival = gsl_matrix_alloc(N, N); sqrt_matrix(A, sqrt_A, esv, eival, eivec, sqrt_eival); // Free workspaces gsl_matrix_free(sqrt_eival); gsl_eigen_symmv_free(esv); gsl_matrix_free(eivec); gsl_vector_free(eival); }
void multi_gauss::generate_eigenvectors(double **covar_matrix, double scale_used){ scale = scale_used; size_t size_used=size; double value; double *tempArray; tempArray = new double[size*size]; int k=0; for(int i=0;i<size_used;++i){ for(int j=0;j<size_used;++j){ tempArray[k]=covar_matrix[i][j]; k++; } } //From GNU Scientific Library gsl_eigen_symmv_workspace *w = gsl_eigen_symmv_alloc(size_used); gsl_matrix_view m = gsl_matrix_view_array(tempArray,size_used,size_used); // ordering of rows and columns is irrelevant, as this is a symmetric matrix. gsl_vector *eval = gsl_vector_alloc(size_used); gsl_matrix *evec = gsl_matrix_alloc(size_used, size_used); // obtain eigenvalues and eigenvectors gsl_eigen_symmv (&m.matrix, eval, evec, w); gsl_eigen_symmv_free(w); // sort in ascending order (not strictly neccessary) gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_ASC); for(int i=0;i<size_used;++i) { // copy into the class member variables. eigenvalues[i] = gsl_vector_get (eval, i); for (int j=0;j<size_used;++j){ value=gsl_matrix_get(evec,i,j); master_matrix[i][j]=value; } } for(int i=0;i<size_used;++i) eigenvalues[i] *= scale; gsl_vector_free(eval); gsl_matrix_free(evec); delete[] tempArray; }
int main (void) { double data[] = { 1.0 , 1/2.0, 1/3.0, 1/4.0, 1/2.0, 1/3.0, 1/4.0, 1/5.0, 1/3.0, 1/4.0, 1/5.0, 1/6.0, 1/4.0, 1/5.0, 1/6.0, 1/7.0 }; gsl_matrix_view m = gsl_matrix_view_array (data, 4, 4); gsl_vector *eval = gsl_vector_alloc (4); gsl_matrix *evec = gsl_matrix_alloc (4, 4); gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (4); gsl_eigen_symmv (&m.matrix, eval, evec, w); gsl_eigen_symmv_free (w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); { int i; for (i = 0; i < 4; i++) { double eval_i = gsl_vector_get (eval, i); gsl_vector_view evec_i = gsl_matrix_column (evec, i); printf ("eigenvalue = %g\n", eval_i); printf ("eigenvector = \n"); gsl_vector_fprintf (stdout, &evec_i.vector, "%g"); } } gsl_vector_free (eval); gsl_matrix_free (evec); return 0; }
void array::save_eigens_to(array &values, array &vectors) { switch(is_2d_array and (not deleted_array)) { case true: switch(values.is_const_array or vectors.is_const_array) { case false: break; case true: return; break; } #pragma omp parallel sections num_threads(2) { #pragma omp section { switch(this -> sizeof_row == values.sizeof_row) { case false: values.resize(this -> sizeof_row); break; } } #pragma omp section { switch((this -> sizeof_row == vectors.sizeof_row) and (this -> sizeof_column == vectors.sizeof_column)) { case false: vectors.resize(this -> sizeof_row, this -> sizeof_column); break; } } } gsl_eigen_symmv_workspace *memory_allocation = gsl_eigen_symmv_alloc(this -> sizeof_row*4); // gsl_eigen_symmv(&gsl_2d_view.matrix, &values.gsl_1d_view.vector, &vectors.gsl_2d_view.matrix, memory_allocation); // gsl_eigen_symmv_free(memory_allocation); break; } }
/** * Empirical Orthogonal Functions analysis (or Principal Component Analysis) * of a multivariate time series. * \param[in] data Multivariate time series on which to perform the analysis. * \param[out] w Eigenvalues of the covariance matrix giving the explained variance. * \param[out] E Matrix with an Empirical Orthogonal Function for each column. * \param[out] A Matrix with a principal component for each column. */ void getEOF(const gsl_matrix *data, gsl_vector *w, gsl_matrix *E, gsl_matrix *A) { size_t nt = data->size1; size_t N = data->size2; gsl_vector *mean; gsl_matrix *C = gsl_matrix_alloc(N, N); gsl_eigen_symmv_workspace *work = gsl_eigen_symmv_alloc(N); gsl_matrix *X = gsl_matrix_alloc(data->size1, data->size2); gsl_matrix_memcpy(X, data); gsl_vector_view col; // Get anomalies A = gsl_matrix_alloc(nt, N); gsl_matrix_memcpy(A, X); mean = gsl_vector_alloc(N); gsl_matrix_get_mean(mean, A, 0); for (size_t j = 0; j < X->size2; j++) { col = gsl_matrix_column(X, j); gsl_vector_add_constant(&col.vector, - gsl_vector_get(mean, j)); } // Get correlation matrix gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1., A, A, 0., C); gsl_matrix_scale(C, 1. / nt); // Solve eigen problem and sort by descending magnitude gsl_eigen_symmv(C, w, E, work); gsl_eigen_symmv_sort(w, E, GSL_EIGEN_SORT_VAL_DESC); // Get principal components gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1., X, E, 0., A); // Free gsl_eigen_symmv_free(work); gsl_matrix_free(C); return; }
TGaussianMixture::TGaussianMixture(unsigned int _ndim, unsigned int _nclusters) : ndim(_ndim), nclusters(_nclusters) { w = new double[nclusters]; mu = new double[ndim*nclusters]; cov = new gsl_matrix*[nclusters]; inv_cov = new gsl_matrix*[nclusters]; sqrt_cov = new gsl_matrix*[nclusters]; for(unsigned int k=0; k<nclusters; k++) { cov[k] = gsl_matrix_alloc(ndim, ndim); inv_cov[k] = gsl_matrix_alloc(ndim, ndim); sqrt_cov[k] = gsl_matrix_alloc(ndim, ndim); } det_cov = new double[nclusters]; LU = gsl_matrix_alloc(ndim, ndim); p = gsl_permutation_alloc(ndim); esv = gsl_eigen_symmv_alloc(ndim); eival = gsl_vector_alloc(ndim); eivec = gsl_matrix_alloc(ndim, ndim); sqrt_eival = gsl_matrix_alloc(ndim, ndim); seed_gsl_rng(&r); }
static void diagonalize_covariance(void) { gsl_vector *vec_dum=gsl_vector_alloc(glob_n_nu); gsl_matrix *evec_dum=gsl_matrix_alloc(glob_n_nu,glob_n_nu); gsl_vector *eval_dum=gsl_vector_alloc(glob_n_nu); eigenvals=gsl_vector_alloc(glob_n_nu); eigenvecs=gsl_matrix_alloc(glob_n_nu,glob_n_nu); //Diagonalize gsl_eigen_symmv_workspace *w=gsl_eigen_symmv_alloc(glob_n_nu); gsl_eigen_symmv(covariance,eval_dum,evec_dum,w); gsl_eigen_symmv_free(w); //Sort eigenvalues gsl_permutation *p=gsl_permutation_alloc(glob_n_nu); gsl_sort_vector_index(p,eval_dum); int ii; for(ii=0;ii<glob_n_nu;ii++) { int inew=gsl_permutation_get(p,ii); gsl_vector_set(eigenvals,ii,gsl_vector_get(eval_dum,inew)); gsl_matrix_get_col(vec_dum,evec_dum,inew); gsl_matrix_set_col(eigenvecs,ii,vec_dum); } gsl_permutation_free(p); gsl_vector_free(vec_dum); gsl_vector_free(eval_dum); gsl_matrix_free(evec_dum); FILE *fo; char fname[256]; sprintf(fname,"%s_pca_eigvals.dat",glob_prefix_out); fo=my_fopen(fname,"w"); for(ii=0;ii<glob_n_nu;ii++) { double lambda=gsl_vector_get(eigenvals,ii); fprintf(fo,"%d %lE\n",ii,lambda); } fclose(fo); }
/** * Determine a direction vector from the orientation matrix. * * NOTE: vec should be *initialized* to be a unit vector -- its value is used, * then replaced */ int XLALSimInspiralOrientationMatrixDirection( REAL8 vec[3], /**< 3 dim unit vector, modified in place */ REAL8 mtx[3][3] /**< 3x3 orientation matrix */ ) { REAL8 vecLast[3]; gsl_matrix *m = gsl_matrix_alloc(3,3); gsl_vector *eval = gsl_vector_alloc(3); gsl_matrix *evec = gsl_matrix_alloc(3,3); gsl_eigen_symmv_workspace *w = gsl_eigen_symmv_alloc(3); int i,j; vecLast[0] = vec[0]; vecLast[1] = vec[1]; vecLast[2]=vec[2]; for (i=0; i<3; i++) { for (j=0; j<3; j++) { gsl_matrix_set(m,i,j,mtx[i][j]); } } gsl_eigen_symmv(m, eval, evec, w); gsl_eigen_symmv_free(w); gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_ABS_ASC); for (i=0; i<3; i++) { vec[i] = gsl_matrix_get(evec,2,i); } if (vecLast[0]*vec[0] + vecLast[1]*vec[1] + vecLast[2]*vec[2] <0) { for (i=0; i<3; i++) { vec[i] = - vec[i]; } } gsl_vector_free(eval); gsl_matrix_free(evec); return XLAL_SUCCESS; }
void Matrix33::Eigen( std::vector<real>& Eval, std::vector<Vector3>& Evec ) const { // std::cout << " in Eigen()..." << std::endl; gsl_matrix_view m = gsl_matrix_view_array( data_, 3, 3 ); gsl_vector *eval = gsl_vector_alloc ( 3 ); gsl_matrix *evec = gsl_matrix_alloc ( 3, 3 ); gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc ( 3 ); gsl_eigen_symmv ( &m.matrix, eval, evec, w ); gsl_eigen_symmv_free ( w ); //gsl_eigen_symmv_sort ( eval, evec, GSL_EIGEN_SORT_ABS_ASC ); gsl_eigen_symmv_sort ( eval, evec, GSL_EIGEN_SORT_VAL_ASC ); for ( unsigned i = 0; i < 3; ++i ) { //double eval_i = gsl_vector_get (eval, i); gsl_vector_view evec_i = gsl_matrix_column (evec, i); Eval.at(i) = gsl_vector_get ( eval, i ); for ( unsigned j = 0; j < 3; ++j ){ (Evec.at(i))(j) = gsl_vector_get( &evec_i.vector, j ); } } }
static void solve_u_v(double d[3], double u[3], double v[3]) { double data[9] = { d[0] * d[0], d[1] * d[0], d[2] * d[0], d[0] * d[1], d[1] * d[1], d[2] * d[1], d[0] * d[2], d[1] * d[2], d[2] * d[2], }; gsl_matrix_view m = gsl_matrix_view_array(data, 3, 3); gsl_vector * eval = gsl_vector_alloc(3); gsl_matrix * evac = gsl_matrix_alloc(3, 3); gsl_eigen_symmv_workspace * work = gsl_eigen_symmv_alloc(3); gsl_eigen_symmv(&m.matrix, eval, evac, work); gsl_eigen_symmv_sort(eval, evac, GSL_EIGEN_SORT_ABS_ASC); gsl_vector_view u_view = gsl_matrix_column(evac, 0); gsl_vector_view v_view = gsl_matrix_column(evac, 1); int i; for(i = 0; i < 3; i++) { u[i] = gsl_vector_get(&u_view.vector, i); v[i] = gsl_vector_get(&v_view.vector, i); } gsl_matrix_free(evac); gsl_vector_free(eval); gsl_eigen_symmv_free(work); }