void find_eigens2(gsl_matrix *m, gsl_vector *eval,gsl_matrix *evec)
{
gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (3);
gsl_eigen_symmv (m, 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 < 3; i++)
{
double eval_i= gsl_vector_get (eval, i);
gsl_vector_view evec_i= gsl_matrix_column (evec, i);
gsl_vector_fprintf (stdout,&evec_i.vector, "%g");
}
}
gsl_vector_free (eval);
gsl_matrix_free (evec);
}
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);
}
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);
}
void Geo3d_Cov_Orientation(double *cov, double *vec, double *ext)
{
#ifdef HAVE_LIBGSL
gsl_matrix_view gmv = gsl_matrix_view_array(cov, 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(&(gmv.matrix), eval, evec, w);
gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_VAL_DESC);
if(ext != NULL) {
darraycpy(ext, gsl_vector_const_ptr(eval, 0), 0, 3);
}
gsl_vector_view v = gsl_vector_view_array(vec, 3);
gsl_matrix_get_col(&(v.vector), evec, 0);
gsl_vector_free(eval);
gsl_matrix_free(evec);
gsl_eigen_symmv_free(w);
#else
double eigv[3];
Matrix_Eigen_Value_Cs(cov[0], cov[4], cov[8], cov[1], cov[2], cov[5], eigv);
Matrix_Eigen_Vector_Cs(cov[0], cov[4], cov[8], cov[1], cov[2], cov[5],
eigv[0], vec);
if(ext != NULL) {
darraycpy(ext, eigv, 0, 3);
}
#endif
}
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);
}
/* 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);
}
/* Function: destroyPCA
*
* Description: de-allocate memory for matrices and vectors used for PCA calculation
*
* Parameters:
* data: PCA data structure to de-allocate memory for
*/
void destroyPCA(_InOut_ Data *data)
{
gsl_eigen_symmv_free(data->workspace);
gsl_matrix_free(data->meanSubstractedPoints);
gsl_vector_free(data->mean);
gsl_matrix_free(data->eigenvectors);
gsl_vector_free(data->eigenvalues);
gsl_matrix_free(data->covarianceMatrix);
}
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_eigen_gensymmv_free (gsl_eigen_gensymmv_workspace * w)
{
RETURN_IF_NULL (w);
if (w->symmv_workspace_p)
gsl_eigen_symmv_free(w->symmv_workspace_p);
free(w);
} /* gsl_eigen_gensymmv_free() */
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);
}
/// 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 ssm_calc_free(ssm_calc_t *calc, ssm_nav_t *nav)
{
gsl_rng_free(calc->randgsl);
if (nav->implementation == SSM_ODE || nav->implementation == SSM_EKF){
gsl_odeiv2_step_free(calc->step);
gsl_odeiv2_evolve_free(calc->evolve);
gsl_odeiv2_control_free(calc->control);
if(nav->implementation == SSM_EKF){
gsl_vector_free(calc->_pred_error);
gsl_matrix_free(calc->_St);
gsl_matrix_free(calc->_Stm1);
gsl_matrix_free(calc->_Rt);
gsl_matrix_free(calc->_Ht);
gsl_matrix_free(calc->_Kt);
gsl_matrix_free(calc->_Tmp_N_SV_N_TS);
gsl_matrix_free(calc->_Tmp_N_TS_N_SV);
gsl_matrix_free(calc->_Q);
gsl_matrix_free(calc->_FtCt);
gsl_matrix_free(calc->_Ft);
gsl_vector_free(calc->_eval);
gsl_matrix_free(calc->_evec);
gsl_eigen_symmv_free(calc->_w_eigen_vv);
}
} else if (nav->implementation == SSM_SDE){
free(calc->y_pred);
} else if (nav->implementation == SSM_PSR){
ssm_psr_free(calc);
}
free(calc->to_be_sorted);
free(calc->index_sorted);
if(calc->covariates_length){
int k;
for(k=0; k< calc->covariates_length; k++) {
if(calc->spline[k]){
gsl_spline_free(calc->spline[k]);
}
if(calc->acc[k]){
gsl_interp_accel_free(calc->acc[k]);
}
}
free(calc->spline);
free(calc->acc);
}
free(calc);
}
/*******************************************************************************
* 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 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
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;
}
void gsl_sf_mathieu_free(gsl_sf_mathieu_workspace *workspace)
{
gsl_vector_free(workspace->eval);
gsl_matrix_free(workspace->evec);
gsl_eigen_symmv_free(workspace->wmat);
free(workspace->aa);
free(workspace->bb);
free(workspace->dd);
free(workspace->ee);
free(workspace->tt);
free(workspace->e2);
free(workspace->zz);
free(workspace);
}
// 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); }
}
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;
}
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;
}
}
TGaussianMixture::~TGaussianMixture() {
delete[] w;
delete[] mu;
for(unsigned int k=0; k<nclusters; k++) {
gsl_matrix_free(cov[k]);
gsl_matrix_free(inv_cov[k]);
gsl_matrix_free(sqrt_cov[k]);
}
delete[] cov;
delete[] inv_cov;
delete[] sqrt_cov;
delete[] det_cov;
gsl_matrix_free(LU);
gsl_permutation_free(p);
gsl_eigen_symmv_free(esv);
gsl_vector_free(eival);
gsl_matrix_free(eivec);
gsl_matrix_free(sqrt_eival);
gsl_rng_free(r);
}
/**
* 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;
}
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;
}
