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() */
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 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 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);
}
void eig (Matrix& src, double* evals, Matrix& evec)
{
gsl_eigen_symmv (src.get_gsl_matrix(), eigen_values, evec.get_gsl_matrix(), eigv_work);
gsl_eigen_symmv_sort (eigen_values, evec.get_gsl_matrix(), GSL_EIGEN_SORT_VAL_ASC);
for (guint i = 0; i < src.rows(); i++)
evals[i] = gsl_vector_get (eigen_values, i);
}
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 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 Schrodinger_Solve(double dx, int Dim, int barrier_L, int barrier_R, double E_well, double *Meff_ptr, double *subband_ptr,
gsl_eigen_symmv_workspace *Workspace, gsl_matrix *Hamil_ptr, gsl_vector *Eigvalue_ptr, gsl_matrix *Eigvector_ptr,
gsl_vector *s_eigvector_ptr, gsl_vector *Potential_ptr, gsl_matrix *Norm_Eigvector_ptr, FILE *fp_1, FILE *fp_2 ){
int n, m, N=0;
double Hbar=1.054571E-34, Element;
double t_0=(Hbar*Hbar)/(2*dx*dx);
for (n = 0; n < Dim; n++)
{
for (m = 0; m < Dim; m++)
{
if (n == m) /*main diagonal*/
{
Element = t_0/Meff_ptr[n-1] + t_0/Meff_ptr[n+1] + gsl_vector_get(Potential_ptr, n);
}
else if (n == m-1) /*subdiagonal*/
{
Element = -1*t_0/Meff_ptr[n-1];
}
else if (n == m+1) /*superdiagonal*/
{
Element = -1*t_0/Meff_ptr[n+1];
}
else
{
Element = 0;
/*all other matrix elements*/
}
gsl_matrix_set(Hamil_ptr, n, m, Element);
/*transfer value to matrix*/
}
}
gsl_eigen_symmv(Hamil_ptr, Eigvalue_ptr, Eigvector_ptr, Workspace);
/*solve matrix*/
gsl_eigen_symmv_sort(Eigvalue_ptr, Eigvector_ptr, GSL_EIGEN_SORT_VAL_ASC);
/*re-order the results in ascending order*/
/*output eigenvalues*/
for (n = 0; n < Dim; n++){
double eigenvalue = gsl_vector_get(Eigvalue_ptr, n);
if (eigenvalue>E_well && eigenvalue<0) /*select confined states*/
{
fprintf(fp_1, "n%E", (eigenvalue/1.6E-22));
/*output in meV*/
subband_ptr[n] = eigenvalue; /*For Fermi-Dirac */
N = N+1;
/* sum the number of eigenstates*/
}
}
/*output eigenvectors*/
for (n = 0; n < N; n++){ /*retrieve eigenvectors for confined states only*/
fprintf(fp_2, "nnnn");
gsl_matrix_get_col(s_eigvector_ptr, Eigvector_ptr, n);
/*retrieve nth eigenvector*/
Normalise(s_eigvector_ptr, Dim, dx, fp_2);
/*normalise eigenvector*/
gsl_matrix_set_col(Norm_Eigvector_ptr, n, s_eigvector_ptr);
}
return N;
}
/* 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
int
gsl_eigen_gensymmv_sort (gsl_vector * eval, gsl_matrix * evec,
gsl_eigen_sort_t sort_type)
{
int s;
s = gsl_eigen_symmv_sort(eval, evec, sort_type);
return s;
}
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 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;
}
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 dc_eig(gsl_matrix *sym, gsl_vector *eval, gsl_matrix *evec ,size_t NCOMP){
// Divide and conquer Eigen decomposition
// gsl_matrix *evec = gsl_matrix_alloc(NSUB, NSUB);
// gsl_vector *eval = gsl_vector_alloc(NCOMP); //eigen values
size_t NSUB = sym->size1;
gsl_vector *eval_temp =gsl_vector_alloc(NSUB);
LAPACKE_dsyevd(LAPACK_ROW_MAJOR, 'V', 'U',
NSUB, sym->data, NSUB, eval_temp->data);
gsl_eigen_symmv_sort (eval_temp, sym, GSL_EIGEN_SORT_ABS_DESC);
gsl_matrix_view temp = gsl_matrix_submatrix(sym, 0,0 , NSUB, NCOMP);
gsl_matrix_memcpy(evec,&temp.matrix);
gsl_vector_view temp_vec = gsl_vector_subvector(eval_temp, 0, NCOMP);
gsl_vector_memcpy(eval, &temp_vec.vector);
gsl_vector_free(eval_temp);
}
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;
}
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 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;
}
/**
* 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;
}
/**
* 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);
}
void alignMesh( Polyhedron & poly )
{
int num = poly.size_of_vertices();
// initialization here is very important!!
Point3 ave( 0.0, 0.0, 0.0 );
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
ave = ave + ( vi->point() - CGAL::ORIGIN );
}
ave = CGAL::ORIGIN + ( ave - CGAL::ORIGIN )/( double )num;
unsigned int dim = 3;
double * data = new double [ num*dim ];
int nPoints = 0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
data[ nPoints * dim + 0 ] = vi->point().x() - ave.x();
data[ nPoints * dim + 1 ] = vi->point().y() - ave.y();
data[ nPoints * dim + 2 ] = vi->point().z() - ave.z();
nPoints++;
}
assert( nPoints == ( int )num );
/*****************************************
analyze the engenstructure of X^T X
*****************************************/
/* define the matrix X */
gsl_matrix_view X = gsl_matrix_view_array( data, num, dim );
/* memory reallocation */
// proj = ( double * )realloc( proj, sizeof( double ) * PDIM * num );
/* calculate the covariance matrix B */
gsl_matrix * B = gsl_matrix_alloc( dim, dim );
gsl_blas_dgemm( CblasTrans, CblasNoTrans, 1.0,
&(X.matrix),
&(X.matrix), 0.0,
B );
/* divided by the number of samples */
gsl_matrix_scale( B, 1.0/(double)num );
gsl_vector * eVal = gsl_vector_alloc( dim );
gsl_matrix * eVec = gsl_matrix_alloc( dim, dim );
gsl_eigen_symmv_workspace * w
= gsl_eigen_symmv_alloc( dim );
// eigenanalysis of the matrix B
gsl_eigen_symmv( B, eVal, eVec, w );
// release the memory of w
gsl_eigen_symmv_free( w );
// sort eigenvalues in a descending order
gsl_eigen_symmv_sort( eVal, eVec, GSL_EIGEN_SORT_VAL_DESC );
// #ifdef MYDEBUG
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "Eigenvalue No. " << i << " = " << gsl_vector_get( eVal, i ) << endl;
cerr << "Eigenvector No. " << i << endl;
double length = 0.0;
for ( unsigned int j = 0; j < dim; ++j ) {
cerr << gsl_matrix_get( eVec, i, j ) << " ";
length += gsl_matrix_get( eVec, i, j )*gsl_matrix_get( eVec, i, j );
}
cerr << " length = " << length << endl;
}
// #endif // MYDEBUG
// 0 1 2, 0 2 1,
Transformation3 map;
map =
Transformation3( gsl_matrix_get(eVec,1,0), gsl_matrix_get(eVec,0,0), gsl_matrix_get(eVec,2,0),
gsl_matrix_get(eVec,1,1), gsl_matrix_get(eVec,0,1), gsl_matrix_get(eVec,2,1),
gsl_matrix_get(eVec,1,2), gsl_matrix_get(eVec,0,2), gsl_matrix_get(eVec,2,2) );
if ( map.is_odd() ) {
cerr << " Transformation matrix reflected" << endl;
map =
Transformation3( gsl_matrix_get(eVec,1,0), gsl_matrix_get(eVec,0,0), -gsl_matrix_get(eVec,2,0),
gsl_matrix_get(eVec,1,1), gsl_matrix_get(eVec,0,1), -gsl_matrix_get(eVec,2,1),
gsl_matrix_get(eVec,1,2), gsl_matrix_get(eVec,0,2), -gsl_matrix_get(eVec,2,2) );
}
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "| ";
for ( unsigned int j = 0; j < dim; ++j ) {
cerr << map.cartesian( i, j ) << " ";
}
cerr << "|" << endl;
}
transformMesh( poly, map );
return;
}
//------------------------------------------------------------------------------
// Align the mesh
//------------------------------------------------------------------------------
Vector3 principalAxis( Polyhedron & poly )
{
int num = poly.size_of_vertices();
// initialization here is very important!!
Point3 ave( 0.0, 0.0, 0.0 );
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
ave = ave + ( vi->point() - CGAL::ORIGIN );
}
ave = CGAL::ORIGIN + ( ave - CGAL::ORIGIN )/( double )num;
unsigned int dim = 3;
double * data = new double [ num*dim ];
int nPoints = 0;
for ( Vertex_iterator vi = poly.vertices_begin(); vi != poly.vertices_end(); ++vi ) {
data[ nPoints * dim + 0 ] = vi->point().x() - ave.x();
data[ nPoints * dim + 1 ] = vi->point().y() - ave.y();
data[ nPoints * dim + 2 ] = vi->point().z() - ave.z();
nPoints++;
}
assert( nPoints == ( int )num );
/*****************************************
analyze the engenstructure of X^T X
*****************************************/
/* define the matrix X */
gsl_matrix_view X = gsl_matrix_view_array( data, num, dim );
/* memory reallocation */
// proj = ( double * )realloc( proj, sizeof( double ) * PDIM * num );
/* calculate the covariance matrix B */
gsl_matrix * B = gsl_matrix_alloc( dim, dim );
gsl_blas_dgemm( CblasTrans, CblasNoTrans, 1.0,
&(X.matrix),
&(X.matrix), 0.0,
B );
/* divided by the number of samples */
gsl_matrix_scale( B, 1.0/(double)num );
gsl_vector * eVal = gsl_vector_alloc( dim );
gsl_matrix * eVec = gsl_matrix_alloc( dim, dim );
gsl_eigen_symmv_workspace * w
= gsl_eigen_symmv_alloc( dim );
// eigenanalysis of the matrix B
gsl_eigen_symmv( B, eVal, eVec, w );
// release the memory of w
gsl_eigen_symmv_free( w );
// sort eigenvalues in a descending order
gsl_eigen_symmv_sort( eVal, eVec, GSL_EIGEN_SORT_VAL_DESC );
#ifdef MYDEBUG
for ( unsigned int i = 0; i < dim; ++i ) {
cerr << "Eigenvalue No. " << i << " = " << gsl_vector_get( eVal, i ) << endl;
cerr << "Eigenvector No. " << i << endl;
for ( unsigned int j = 0; j < dim; ++j ) {
length += gsl_matrix_get( eVec, i, j )*gsl_matrix_get( eVec, i, j );
}
cerr << " length = " << length << endl;
}
#endif // MYDEBUG
Vector3 ref( gsl_matrix_get( eVec, 0, 0 ),
gsl_matrix_get( eVec, 0, 1 ),
gsl_matrix_get( eVec, 0, 2 ) );
return ref;
#ifdef DEBUG
gsl_vector_view eachVec = gsl_matrix_column( eigenVec, 0 );
double cosRot = gsl_matrix_get( eigenVec, 0, 1 );
double sinRot = gsl_matrix_get( eigenVec, 1, 1 );
#ifdef DEBUG
cerr << " 2nd axis : " << cosRot << " , " << sinRot << endl;
#endif // DEBUG
Transformation2 rotate( CGAL::ROTATION, -sinRot, cosRot );
for ( unsigned int i = 0; i < subpatch.size(); ++i ) {
subpatch[ i ]->triangle() = subpatch[ i ]->triangle().transform( rotate );
}
#endif // DEBUG
}
PetscErrorCode cHamiltonianMatrix::initial_state(){
gsl_matrix *H0 = gsl_matrix_alloc(L,L);
gsl_matrix_set_zero(H0);
for (int j = 0; j < L; ++j) {
if (judgeB==1) {
gsl_matrix_set(H0,j,j,gsl_vector_get(randV,j));
}
if (j==0) {
gsl_matrix_set(H0,j,j+1,-1.0);
} else if(j==L-1){
gsl_matrix_set(H0,j,j-1,-1.0);
} else {
gsl_matrix_set(H0,j,j+1,-1.0);
gsl_matrix_set(H0,j,j-1,-1.0);
}
}
// for (int i = 0; i < L; ++i) {
// for (int j = 0; j < L; ++j) {
// cout << gsl_matrix_get(H0,i,j) << '\t' ;
// }
// cout << endl;
// }
gsl_vector *eval = gsl_vector_alloc (L);
gsl_matrix *evec = gsl_matrix_alloc (L, L);
gsl_eigen_symmv_workspace * w_symmv = gsl_eigen_symmv_alloc (L);
gsl_eigen_symmv (H0, eval, evec, w_symmv);
gsl_eigen_symmv_free (w_symmv);
gsl_eigen_symmv_sort (eval, evec, GSL_EIGEN_SORT_VAL_ASC);
// for (int i = 0; i < L; ++i) {
// cout << i+1 << "th eigenvalue is " << gsl_vector_get (eval, i) << endl;
// gsl_vector_view evec_i = gsl_matrix_column (evec, i);
// gsl_vector_fprintf (stdout, &evec_i.vector, "%g");
// }
// %initial state---zero temperature.
ierr = VecCreate(PETSC_COMM_WORLD,&X1);CHKERRQ(ierr);
ierr = VecSetSizes(X1,nlocal,DIM);CHKERRQ(ierr);
ierr = VecSetFromOptions(X1);CHKERRQ(ierr);
ierr = VecDuplicate(X1,&X2);CHKERRQ(ierr);
gsl_vector * site2 = gsl_vector_alloc(N2);
gsl_vector_set(site2,0,position);
if (N2>1) for (int i = 1; i < N2; ++i) gsl_vector_set(site2,i,0);
int p2 = myindex(site2,N2); //%index of impurity particle, also the position on the lattice
rr = gsl_vector_alloc (DIM);
// Translation of the matlab code...
// rr=1-p2:1:L-p2;
// mm=ones(dim,1);
// rr=kron(rr',mm);%departure distance!
for (int irr = 0; irr < dim2; ++irr) {
for (int imm = 0; imm < dim; ++imm) {
gsl_vector_set(rr,irr*dim+imm,1-p2+irr);
}
}
// if (rank==0){
// for (int ivar = 0; ivar < DIM; ++ivar) {
// cout << gsl_vector_get(rr,ivar) << endl;
// }
// }
double val_det;
gsl_matrix *slater = gsl_matrix_alloc(N,N);
gsl_permutation *p = gsl_permutation_alloc(slater->size1);
int signum;
for (int jdim = 0; jdim < dim; ++jdim) {
for (int j1 = 0; j1 < N; ++j1) { // row
for (int j2 = 0; j2 < N; ++j2) { // col
gsl_matrix_set(slater,j1,j2,gsl_matrix_get(evec, gsl_matrix_get(basis1,j1,jdim)-1,j2));
}
}
gsl_linalg_LU_decomp(slater , p , &signum); // cout << "rank " << rank << " has signum " << signum << endl;
val_det = gsl_linalg_LU_det(slater , signum);
// cout << jdim+1 << "th slater det is " << val_det << endl;
ierr = VecSetValue(X1,(p2-1)*dim+jdim,val_det, INSERT_VALUES); // X1 is the initial state vector0.
}
ierr = VecAssemblyBegin(X1); CHKERRQ(ierr);
ierr = VecAssemblyEnd(X1); CHKERRQ(ierr);
// ierr = PetscViewerSetFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_MATLAB);
// ierr = VecView(X1,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
gsl_permutation_free (p);
gsl_vector_free(site2);
gsl_matrix_free(slater);
gsl_vector_free (eval);
gsl_matrix_free (evec);
gsl_matrix_free (H0);
return ierr;
}
int main(int argc, char **argv){
FILE *data;
double *matriz;
int x,y,i,j,a;
int m3=0,m1=0,m2=0;
data=opendata(argv[1]);
countdata(data,&x,&y);
//hacer la matriz provisional
matriz = loaddata(data,x,y);
gsl_matrix_view P =gsl_matrix_view_array(matriz,y,x);
// sacar la media para cada dimension
gsl_vector *m= gsl_vector_alloc(3);
for(i=0;i<x;i++){
for(j=0;j<y;j++){
if(i==0)
{
m1+= gsl_matrix_get(&P.matrix,j,i);
}
if(i==1)
{
m2+= gsl_matrix_get(&P.matrix,j,i);
}
if(i==2)
{
m3+= gsl_matrix_get(&P.matrix,j,i);
}
m1/= y; m2/= y; m3/=y;
}
}
gsl_vector_set(m,0,m1);
gsl_vector_set(m,1,m2);
gsl_vector_set(m,2,m3);
// crear la matriz de covarianza COV
gsl_matrix *COV= gsl_matrix_alloc(x,x);
for(i=0;i<x;i++){
for(a=0;a<x;a++){
double element=0;
for(j=0;j<y;j++){
double ei= gsl_matrix_get(&P.matrix,j,i) - gsl_vector_get(m,i);
double ea= gsl_matrix_get(&P.matrix,j,a) - gsl_vector_get(m,a);
double ee=ei*ea;
element+=ee;
}
element/= (y-1);
gsl_matrix_set(COV,i,a,element);
}
}
// calcular los valores propios de la matriz COV
gsl_vector *eval=gsl_vector_alloc(x);
gsl_matrix *evec=gsl_matrix_alloc(x,x);
gsl_eigen_symmv_workspace *w= gsl_eigen_symmv_alloc(x);
gsl_eigen_symmv(COV,eval,evec,w);
gsl_eigen_symmv_free(w);
gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
//output
FILE *fileout;
fileout=fopen("autovectores_3D_data.dat", "w");
for(i=0;i<x-1;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");
float evec_i_0= (float) gsl_vector_get(&evec_i.vector,0);
float evec_i_1= (float) gsl_vector_get(&evec_i.vector,1);
float evec_i_2= (float) gsl_vector_get(&evec_i.vector,2);
fprintf(fileout,"%f %f %f\n", evec_i_0, evec_i_1, evec_i_2);
}
close(fileout);
return 0;
}
int main(int argc, char **argv)
{
gsl_matrix *Original;
gsl_matrix *Mtr_Cov;
FILE *input;
int num_lineas;
int i,j,k;
double var;
/*---------------------------------------------------------
Verifica cuales archivos fueron usados como input y se asegura de que solo haya cargado uno.
-----------------------------------------------------------*/
printf("Este programa se ejecutó con %d argumento(s):\n",argc-1);
for(i=1;i<argc;i++){
printf("%s\n", argv[i]);
}
if(argc!=2){
printf("se necesita 1 argumento además del nombre del ejecutable!,\n EXIT!\n");
exit(1);
}
else{
printf("El archivo a usar es %s\n", argv[1]);
}
//--------------------------------------------------------
input=fopen(argv[1],"r");
if(!input){
printf("surgió un problema abriendo el archivo\n");
exit(1);
}
/*---------------------------------------------------------
toma como archivo base el primer argumento y cuenta sus lineas
-----------------------------------------------------------*/
num_lineas=0;
while ((var = fgetc(input)) != EOF){
if (var =='\n')
++num_lineas;
}
//printf("Número de lineas del archivo:\n -->%d\n",num_lineas);
/*---------------------------------------------------------
Data allocation
-----------------------------------------------------------*/
rewind(input);
Original=gsl_matrix_alloc((num_lineas),24);
// printf("\nOriginal\n");
gsl_matrix_fscanf(input,Original);
//gsl_matrix_fprintf (stdout, Original, "%g");
//CheckPoint
//printf("matriz escaneada\n");
/*---------------------------------------------------------
Promedio
-----------------------------------------------------------*/
float *prom;
int y;
prom=malloc((num_lineas) * sizeof(float));
//printf("...\n");
for(k=0;k<num_lineas;k++){
float suma=0.0;
for(y=0;y<24;y++){
suma+=gsl_matrix_get(Original,k,y);
}
prom[k]=suma/24.0;
}
printf("Checkpoint... Promedios\n");
/*---------------------------------------------------------
Efectos en la matriz
-----------------------------------------------------------*/
Mtr_Cov=gsl_matrix_alloc(num_lineas,num_lineas);
//printf("...\n");
int l,n,m;
double sprite=0;
for(l=0;l<num_lineas;l++){
for(m=0;m<num_lineas;m++){
for(n=1;n<24;n++){
double flan=gsl_matrix_get(Original,m,n);
double agua=prom[m];
double frutino=gsl_matrix_get(Original,l,n);
double tang=prom[l];
double jarra1=(flan-agua);
double jarra2=(frutino-tang);
//printf("%g %g\n",jarra1,jarra2);
sprite=sprite+(jarra1*jarra2)/24;
}
gsl_matrix_set(Mtr_Cov,m,l,sprite);
sprite=0;
}}
/*---------------------------------------------------------
Matriz de covarianza creada;
sacar vectores y valores propios de la matriz.
-----------------------------------------------------------*/
/*
int pa,po;
double can;
for(pa=0;pa<num_lineas;pa++){
for(po=0;po<num_lineas;po++){
can=gsl_matrix_get(Mtr_Cov,po,pa);
printf("%f ",can);
}
printf("\n");
}
*/
gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (num_lineas);
gsl_vector *eval = gsl_vector_alloc (num_lineas);
gsl_matrix *evec = gsl_matrix_alloc (num_lineas,num_lineas);
gsl_eigen_symmv (Mtr_Cov, eval, evec, w);
gsl_eigen_symmv_sort (eval, evec,GSL_EIGEN_SORT_ABS_ASC);
/*---------------------------------------------------------
PON ESA COSA HORROROSA AHI O VERAS!!!
-----------------------------------------------------------*/
FILE *Out1;
FILE *Out2;
Out1 = fopen("JorgeHayek_eigenvalues.dat", "w");
Out2 = fopen("JorgeHayek_eigenvectors.dat", "w");
fprintf(Out1,"EigenValues:\n");
fprintf(Out2,"EigenVectors:\n");
for (i = 0; i < num_lineas; i++)
{
double eval_i = gsl_vector_get (eval, i);
fprintf (Out1,"%g\n", eval_i);
}
for (i = 0; i < 11; i++)
{fprintf(Out2,"--------------------------------------------\nVector %d\n--------------------------------------------\n",i);
gsl_vector_view evec_i
= gsl_matrix_column (evec, i);
gsl_vector_fprintf (Out2,
&evec_i.vector, "%g");
}
/*---------------------------------------------------------
FIN
-----------------------------------------------------------*/
gsl_vector_free (eval);
gsl_matrix_free (evec);
gsl_matrix_free(Original);
fclose(input);
return 0;
}
int gsl_sf_mathieu_a_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[])
{
unsigned int even_order = work->even_order, odd_order = work->odd_order,
extra_values = work->extra_values, ii, jj;
int status;
double *tt = work->tt, *dd = work->dd, *ee = work->ee, *e2 = work->e2,
*zz = work->zz, *aa = work->aa;
gsl_matrix_view mat, evec;
gsl_vector_view eval;
gsl_eigen_symmv_workspace *wmat = work->wmat;
if (order_max > work->size || order_max <= order_min || order_min < 0)
{
GSL_ERROR ("invalid range [order_min,order_max]", GSL_EINVAL);
}
/* Convert the nonsymmetric tridiagonal matrix to a symmetric tridiagonal
form. */
tt[0] = 0.0;
tt[1] = 0.0;
tt[2] = qq;
for (ii=1; ii<even_order-1; ii++)
{
tt[3*ii] = qq;
tt[3*ii+1] = 4*ii*ii;
tt[3*ii+2] = qq;
}
tt[3*even_order-3] = qq;
tt[3*even_order-2] = 4*(even_order - 1)*(even_order - 1);
tt[3*even_order-1] = 0.0;
tt[3] *= 2;
status = figi((signed int)even_order, tt, dd, ee, e2);
if (status)
{
GSL_ERROR("Internal error in tridiagonal Mathieu matrix", GSL_EFAILED);
}
/* Fill the period \pi matrix. */
for (ii=0; ii<even_order*even_order; ii++)
zz[ii] = 0.0;
zz[0] = dd[0];
zz[1] = ee[1];
for (ii=1; ii<even_order-1; ii++)
{
zz[ii*even_order+ii-1] = ee[ii];
zz[ii*even_order+ii] = dd[ii];
zz[ii*even_order+ii+1] = ee[ii+1];
}
zz[even_order*(even_order-1)+even_order-2] = ee[even_order-1];
zz[even_order*even_order-1] = dd[even_order-1];
/* Compute (and sort) the eigenvalues of the matrix. */
mat = gsl_matrix_view_array(zz, even_order, even_order);
eval = gsl_vector_subvector(work->eval, 0, even_order);
evec = gsl_matrix_submatrix(work->evec, 0, 0, even_order, even_order);
gsl_eigen_symmv(&mat.matrix, &eval.vector, &evec.matrix, wmat);
gsl_eigen_symmv_sort(&eval.vector, &evec.matrix, GSL_EIGEN_SORT_VAL_ASC);
for (ii=0; ii<even_order-extra_values; ii++)
aa[2*ii] = gsl_vector_get(&eval.vector, ii);
/* Fill the period 2\pi matrix. */
for (ii=0; ii<odd_order*odd_order; ii++)
zz[ii] = 0.0;
for (ii=0; ii<odd_order; ii++)
for (jj=0; jj<odd_order; jj++)
{
if (ii == jj)
zz[ii*odd_order+jj] = (2*ii + 1)*(2*ii + 1);
else if (ii == jj + 1 || ii + 1 == jj)
zz[ii*odd_order+jj] = qq;
}
zz[0] += qq;
/* Compute (and sort) the eigenvalues of the matrix. */
mat = gsl_matrix_view_array(zz, odd_order, odd_order);
eval = gsl_vector_subvector(work->eval, 0, odd_order);
evec = gsl_matrix_submatrix(work->evec, 0, 0, odd_order, odd_order);
gsl_eigen_symmv(&mat.matrix, &eval.vector, &evec.matrix, wmat);
gsl_eigen_symmv_sort(&eval.vector, &evec.matrix, GSL_EIGEN_SORT_VAL_ASC);
for (ii=0; ii<odd_order-extra_values; ii++)
aa[2*ii+1] = gsl_vector_get(&eval.vector, ii);
for (ii = order_min ; ii <= order_max ; ii++)
{
result_array[ii - order_min] = aa[ii];
}
return GSL_SUCCESS;
}
int gsl_sf_mathieu_b_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[])
{
unsigned int even_order = work->even_order-1, odd_order = work->odd_order,
extra_values = work->extra_values, ii, jj;
double *zz = work->zz, *bb = work->bb;
gsl_matrix_view mat, evec;
gsl_vector_view eval;
gsl_eigen_symmv_workspace *wmat = work->wmat;
if (order_max > work->size || order_max <= order_min || order_min < 0)
{
GSL_ERROR ("invalid range [order_min,order_max]", GSL_EINVAL);
}
/* Fill the period \pi matrix. */
for (ii=0; ii<even_order*even_order; ii++)
zz[ii] = 0.0;
for (ii=0; ii<even_order; ii++)
for (jj=0; jj<even_order; jj++)
{
if (ii == jj)
zz[ii*even_order+jj] = 4*(ii + 1)*(ii + 1);
else if (ii == jj + 1 || ii + 1 == jj)
zz[ii*even_order+jj] = qq;
}
/* Compute (and sort) the eigenvalues of the matrix. */
mat = gsl_matrix_view_array(zz, even_order, even_order);
eval = gsl_vector_subvector(work->eval, 0, even_order);
evec = gsl_matrix_submatrix(work->evec, 0, 0, even_order, even_order);
gsl_eigen_symmv(&mat.matrix, &eval.vector, &evec.matrix, wmat);
gsl_eigen_symmv_sort(&eval.vector, &evec.matrix, GSL_EIGEN_SORT_VAL_ASC);
bb[0] = 0.0;
for (ii=0; ii<even_order-extra_values; ii++)
bb[2*(ii+1)] = gsl_vector_get(&eval.vector, ii);
/* Fill the period 2\pi matrix. */
for (ii=0; ii<odd_order*odd_order; ii++)
zz[ii] = 0.0;
for (ii=0; ii<odd_order; ii++)
for (jj=0; jj<odd_order; jj++)
{
if (ii == jj)
zz[ii*odd_order+jj] = (2*ii + 1)*(2*ii + 1);
else if (ii == jj + 1 || ii + 1 == jj)
zz[ii*odd_order+jj] = qq;
}
zz[0] -= qq;
/* Compute (and sort) the eigenvalues of the matrix. */
mat = gsl_matrix_view_array(zz, odd_order, odd_order);
eval = gsl_vector_subvector(work->eval, 0, odd_order);
evec = gsl_matrix_submatrix(work->evec, 0, 0, odd_order, odd_order);
gsl_eigen_symmv(&mat.matrix, &eval.vector, &evec.matrix, wmat);
gsl_eigen_symmv_sort(&eval.vector, &evec.matrix, GSL_EIGEN_SORT_VAL_ASC);
for (ii=0; ii<odd_order-extra_values; ii++)
bb[2*ii+1] = gsl_vector_get(&eval.vector, ii);
for (ii = order_min ; ii <= order_max ; ii++)
{
result_array[ii - order_min] = bb[ii];
}
return GSL_SUCCESS;
}
/* Function: PCA
*
* Description: Perform PCA calculations and store the results in a CvPoint3D32f
* array
*
* Parameters:
* features3DPrime: CvPoint3D32f array to store the resulting points of the
* PCA calculation, in PCA space
* features3D: the features points to convert to PCA space
* numFeatures: number of features
* PCAData: the matrices and vectors calculated during PCA, saved for later
* reversing the calculations
*/
int PCA(
_Out_ CvPoint3D32f *features3DPrime,
_In_ CvPoint3D32f *features3D,
_In_ int numFeatures,
_Out_ Data *PCAData)
{
double xSum = 0.0;
double ySum = 0.0;
double zSum = 0.0;
// Find mean of each of the dimensions, and store in vector data->mean
for (int i = 0; i < numFeatures; i++)
{
xSum += features3D[i].x;
ySum += features3D[i].y;
zSum += features3D[i].z;
}
gsl_vector_set(PCAData->mean, 0, xSum/(double)numFeatures);
gsl_vector_set(PCAData->mean, 1, ySum/(double)numFeatures);
gsl_vector_set(PCAData->mean, 2, zSum/(double)numFeatures);
// Get mean-substracted data into matrix data->meanSubstractedPoints.
for (int i = 0; i < numFeatures; i++)
{
double meanSubtractedXValue = features3D[i].x - gsl_vector_get(PCAData->mean, 0);
double meanSubtractedYValue = features3D[i].y - gsl_vector_get(PCAData->mean, 1);
double meanSubtractedZValue = features3D[i].z - gsl_vector_get(PCAData->mean, 2);
gsl_matrix_set(PCAData->meanSubstractedPoints, i, 0, meanSubtractedXValue);
gsl_matrix_set(PCAData->meanSubstractedPoints, i, 1, meanSubtractedYValue);
gsl_matrix_set(PCAData->meanSubstractedPoints, i, 2, meanSubtractedZValue);
}
// Compute Covariance matrix
gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0/(double)numFeatures, PCAData->meanSubstractedPoints, PCAData->meanSubstractedPoints, 0.0, PCAData->covarianceMatrix);
// Get eigenvectors, sort by eigenvalue.
gsl_eigen_symmv(PCAData->covarianceMatrix, PCAData->eigenvalues, PCAData->eigenvectors, PCAData->workspace);
gsl_eigen_symmv_sort(PCAData->eigenvalues, PCAData->eigenvectors, GSL_EIGEN_SORT_ABS_DESC);
double maxAbsVals[3] = {0.0, 0.0, 0.0};
// get the maximum absolute value of each column
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
double val = gsl_matrix_get(PCAData->eigenvectors, i, j);
if (fabs(val) > fabs(maxAbsVals[j]))
{
maxAbsVals[j] = val;
}
}
}
// If the maximum absolute value of a column is negative, multiply everything
// in that column by -1. Why? No idea, but that's how the MATLAB PCA function
// does it.
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (maxAbsVals[j] < 0)
{
double val = gsl_matrix_get(PCAData->eigenvectors, i, j);
gsl_matrix_set(PCAData->eigenvectors, i, j, -1 * val);
}
}
}
gsl_matrix *scores = gsl_matrix_alloc(numFeatures, 3);
if (scores == NULL)
{
return OUT_OF_MEMORY_ERROR;
}
// multiply the eigenvectors from the PCA by the feature points with the mean
// subtracted to get the points in PCA space
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, PCAData->meanSubstractedPoints, PCAData->eigenvectors, 0.0, scores);
for (int i = 0; i < numFeatures; i++)
{
features3DPrime[i].x = gsl_matrix_get(scores, i, 0);
features3DPrime[i].y = gsl_matrix_get(scores, i, 1);
features3DPrime[i].z = gsl_matrix_get(scores, i, 2);
}
// cleanup
gsl_matrix_free(scores);
return 0;
}
