c@244: /*********************************/
c@244: /* Principal Components Analysis */
c@244: /*********************************/
c@244: 
c@244: /*********************************************************************/
c@244: /* Principal Components Analysis or the Karhunen-Loeve expansion is a
c@244:    classical method for dimensionality reduction or exploratory data
c@244:    analysis.  One reference among many is: F. Murtagh and A. Heck,
c@244:    Multivariate Data Analysis, Kluwer Academic, Dordrecht, 1987.
c@244: 
c@244:    Author:
c@244:    F. Murtagh
c@244:    Phone:        + 49 89 32006298 (work)
c@244:                  + 49 89 965307 (home)
c@244:    Earn/Bitnet:  fionn@dgaeso51,  fim@dgaipp1s,  murtagh@stsci
c@244:    Span:         esomc1::fionn
c@244:    Internet:     murtagh@scivax.stsci.edu
c@244:    
c@244:    F. Murtagh, Munich, 6 June 1989                                   */   
c@244: /*********************************************************************/
c@244: 
c@244: #include <stdio.h>
c@244: #include <stdlib.h>
c@244: #include <math.h>
c@244: 
c@244: #include "pca.h"
c@244: 
c@244: #define SIGN(a, b) ( (b) < 0 ? -fabs(a) : fabs(a) )
c@244: 
c@244: /**  Variance-covariance matrix: creation  *****************************/
c@244: 
c@244: /* Create m * m covariance matrix from given n * m data matrix. */
c@244: void covcol(double** data, int n, int m, double** symmat)
c@244: {
cannam@483:     double *mean;
cannam@483:     int i, j, j1, j2;
c@244: 
c@244: /* Allocate storage for mean vector */
c@244: 
cannam@483:     mean = (double*) malloc(m*sizeof(double));
c@244: 
c@244: /* Determine mean of column vectors of input data matrix */
c@244: 
cannam@483:     for (j = 0; j < m; j++)
c@244:     {
cannam@483:         mean[j] = 0.0;
cannam@483:         for (i = 0; i < n; i++)
c@244:         {
cannam@483:             mean[j] += data[i][j];
c@244:         }
cannam@483:         mean[j] /= (double)n;
c@244:     }
c@244: 
c@244: /*
cannam@483:   printf("\nMeans of column vectors:\n");
cannam@483:   for (j = 0; j < m; j++)  {
cannam@483:   printf("%12.1f",mean[j]);  }   printf("\n");
cannam@483: */
c@244: 
c@244: /* Center the column vectors. */
c@244: 
cannam@483:     for (i = 0; i < n; i++)
c@244:     {
cannam@483:         for (j = 0; j < m; j++)
c@244:         {
cannam@483:             data[i][j] -= mean[j];
c@244:         }
c@244:     }
c@244: 
c@244: /* Calculate the m * m covariance matrix. */
cannam@483:     for (j1 = 0; j1 < m; j1++)
c@244:     {
cannam@483:         for (j2 = j1; j2 < m; j2++)
c@244:         {
cannam@483:             symmat[j1][j2] = 0.0;
cannam@483:             for (i = 0; i < n; i++)
c@244:             {
cannam@483:                 symmat[j1][j2] += data[i][j1] * data[i][j2];
c@244:             }
cannam@483:             symmat[j2][j1] = symmat[j1][j2];
c@244:         }
c@244:     }
c@244: 
cannam@483:     free(mean);
c@244: 
cannam@483:     return;
c@244: 
c@244: }
c@244: 
c@244: /**  Error handler  **************************************************/
c@244: 
c@244: void erhand(char* err_msg)
c@244: {
c@244:     fprintf(stderr,"Run-time error:\n");
c@244:     fprintf(stderr,"%s\n", err_msg);
c@244:     fprintf(stderr,"Exiting to system.\n");
c@244:     exit(1);
c@244: }
c@244: 
c@244: 
c@244: /**  Reduce a real, symmetric matrix to a symmetric, tridiag. matrix. */
c@244: 
c@244: /* Householder reduction of matrix a to tridiagonal form.
cannam@483:    Algorithm: Martin et al., Num. Math. 11, 181-195, 1968.
cannam@483:    Ref: Smith et al., Matrix Eigensystem Routines -- EISPACK Guide
cannam@483:    Springer-Verlag, 1976, pp. 489-494.
cannam@483:    W H Press et al., Numerical Recipes in C, Cambridge U P,
cannam@483:    1988, pp. 373-374.  */
c@244: void tred2(double** a, int n, double* d, double* e)
c@244: {
cannam@483:     int l, k, j, i;
cannam@483:     double scale, hh, h, g, f;
cannam@483:         
cannam@483:     for (i = n-1; i >= 1; i--)
c@244:     {
cannam@483:         l = i - 1;
cannam@483:         h = scale = 0.0;
cannam@483:         if (l > 0)
cannam@483:         {
cannam@483:             for (k = 0; k <= l; k++)
cannam@483:                 scale += fabs(a[i][k]);
cannam@483:             if (scale == 0.0)
cannam@483:                 e[i] = a[i][l];
cannam@483:             else
cannam@483:             {
cannam@483:                 for (k = 0; k <= l; k++)
cannam@483:                 {
cannam@483:                     a[i][k] /= scale;
cannam@483:                     h += a[i][k] * a[i][k];
cannam@483:                 }
cannam@483:                 f = a[i][l];
cannam@483:                 g = f>0 ? -sqrt(h) : sqrt(h);
cannam@483:                 e[i] = scale * g;
cannam@483:                 h -= f * g;
cannam@483:                 a[i][l] = f - g;
cannam@483:                 f = 0.0;
cannam@483:                 for (j = 0; j <= l; j++)
cannam@483:                 {
cannam@483:                     a[j][i] = a[i][j]/h;
cannam@483:                     g = 0.0;
cannam@483:                     for (k = 0; k <= j; k++)
cannam@483:                         g += a[j][k] * a[i][k];
cannam@483:                     for (k = j+1; k <= l; k++)
cannam@483:                         g += a[k][j] * a[i][k];
cannam@483:                     e[j] = g / h;
cannam@483:                     f += e[j] * a[i][j];
cannam@483:                 }
cannam@483:                 hh = f / (h + h);
cannam@483:                 for (j = 0; j <= l; j++)
cannam@483:                 {
cannam@483:                     f = a[i][j];
cannam@483:                     e[j] = g = e[j] - hh * f;
cannam@483:                     for (k = 0; k <= j; k++)
cannam@483:                         a[j][k] -= (f * e[k] + g * a[i][k]);
cannam@483:                 }
cannam@483:             }
cannam@483:         }
cannam@483:         else
cannam@483:             e[i] = a[i][l];
cannam@483:         d[i] = h;
c@244:     }
cannam@483:     d[0] = 0.0;
cannam@483:     e[0] = 0.0;
cannam@483:     for (i = 0; i < n; i++)
c@244:     {
cannam@483:         l = i - 1;
cannam@483:         if (d[i])
cannam@483:         {
cannam@483:             for (j = 0; j <= l; j++)
cannam@483:             {
cannam@483:                 g = 0.0;
cannam@483:                 for (k = 0; k <= l; k++)
cannam@483:                     g += a[i][k] * a[k][j];
cannam@483:                 for (k = 0; k <= l; k++)
cannam@483:                     a[k][j] -= g * a[k][i];
cannam@483:             }
cannam@483:         }
cannam@483:         d[i] = a[i][i];
cannam@483:         a[i][i] = 1.0;
cannam@483:         for (j = 0; j <= l; j++)
cannam@483:             a[j][i] = a[i][j] = 0.0;
c@244:     }
c@244: }
c@244: 
c@244: /**  Tridiagonal QL algorithm -- Implicit  **********************/
c@244: 
c@244: void tqli(double* d, double* e, int n, double** z)
c@244: {
cannam@483:     int m, l, iter, i, k;
cannam@483:     double s, r, p, g, f, dd, c, b;
cannam@483:         
cannam@483:     for (i = 1; i < n; i++)
cannam@483:         e[i-1] = e[i];
cannam@483:     e[n-1] = 0.0;
cannam@483:     for (l = 0; l < n; l++)
c@244:     {
cannam@483:         iter = 0;
cannam@483:         do
cannam@483:         {
cannam@483:             for (m = l; m < n-1; m++)
cannam@483:             {
cannam@483:                 dd = fabs(d[m]) + fabs(d[m+1]);
cannam@483:                 if (fabs(e[m]) + dd == dd) break;
cannam@483:             }
cannam@483:             if (m != l)
cannam@483:             {
cannam@483:                 if (iter++ == 30) erhand("No convergence in TLQI.");
cannam@483:                 g = (d[l+1] - d[l]) / (2.0 * e[l]);
cannam@483:                 r = sqrt((g * g) + 1.0);
cannam@483:                 g = d[m] - d[l] + e[l] / (g + SIGN(r, g));
cannam@483:                 s = c = 1.0;
cannam@483:                 p = 0.0;
cannam@483:                 for (i = m-1; i >= l; i--)
cannam@483:                 {
cannam@483:                     f = s * e[i];
cannam@483:                     b = c * e[i];
cannam@483:                     if (fabs(f) >= fabs(g))
c@244:                     {
cannam@483:                         c = g / f;
cannam@483:                         r = sqrt((c * c) + 1.0);
cannam@483:                         e[i+1] = f * r;
cannam@483:                         c *= (s = 1.0/r);
c@244:                     }
cannam@483:                     else
c@244:                     {
cannam@483:                         s = f / g;
cannam@483:                         r = sqrt((s * s) + 1.0);
cannam@483:                         e[i+1] = g * r;
cannam@483:                         s *= (c = 1.0/r);
c@244:                     }
cannam@483:                     g = d[i+1] - p;
cannam@483:                     r = (d[i] - g) * s + 2.0 * c * b;
cannam@483:                     p = s * r;
cannam@483:                     d[i+1] = g + p;
cannam@483:                     g = c * r - b;
cannam@483:                     for (k = 0; k < n; k++)
cannam@483:                     {
cannam@483:                         f = z[k][i+1];
cannam@483:                         z[k][i+1] = s * z[k][i] + c * f;
cannam@483:                         z[k][i] = c * z[k][i] - s * f;
cannam@483:                     }
cannam@483:                 }
cannam@483:                 d[l] = d[l] - p;
cannam@483:                 e[l] = g;
cannam@483:                 e[m] = 0.0;
cannam@483:             }
cannam@483:         }  while (m != l);
cannam@483:     }
c@244: }
c@244: 
c@244: /* In place projection onto basis vectors */
c@244: void pca_project(double** data, int n, int m, int ncomponents)
c@244: {
cannam@483:     int  i, j, k, k2;
cannam@483:     double  **symmat, /* **symmat2, */ *evals, *interm;
cannam@483:         
cannam@483:     //TODO: assert ncomponents < m
cannam@483:         
cannam@483:     symmat = (double**) malloc(m*sizeof(double*));
cannam@483:     for (i = 0; i < m; i++)
cannam@483:         symmat[i] = (double*) malloc(m*sizeof(double));
cannam@483:                 
cannam@483:     covcol(data, n, m, symmat);
cannam@483:         
cannam@483:     /*********************************************************************
cannam@483:                 Eigen-reduction
cannam@483:     **********************************************************************/
cannam@483:         
c@244:     /* Allocate storage for dummy and new vectors. */
c@244:     evals = (double*) malloc(m*sizeof(double));     /* Storage alloc. for vector of eigenvalues */
c@244:     interm = (double*) malloc(m*sizeof(double));    /* Storage alloc. for 'intermediate' vector */
c@244:     //MALLOC_ARRAY(symmat2,m,m,double);    
cannam@483:     //for (i = 0; i < m; i++) {
cannam@483:     //      for (j = 0; j < m; j++) {
cannam@483:     //              symmat2[i][j] = symmat[i][j]; /* Needed below for col. projections */
cannam@483:     //      }
cannam@483:     //}
c@244:     tred2(symmat, m, evals, interm);  /* Triangular decomposition */
cannam@483:     tqli(evals, interm, m, symmat);   /* Reduction of sym. trid. matrix */
c@244: /* evals now contains the eigenvalues,
cannam@483:    columns of symmat now contain the associated eigenvectors. */   
c@244: 
c@244: /*
cannam@483:   printf("\nEigenvalues:\n");
cannam@483:   for (j = m-1; j >= 0; j--) {
cannam@483:   printf("%18.5f\n", evals[j]); }
cannam@483:   printf("\n(Eigenvalues should be strictly positive; limited\n");
cannam@483:   printf("precision machine arithmetic may affect this.\n");
cannam@483:   printf("Eigenvalues are often expressed as cumulative\n");
cannam@483:   printf("percentages, representing the 'percentage variance\n");
cannam@483:   printf("explained' by the associated axis or principal component.)\n");
cannam@483:         
cannam@483:   printf("\nEigenvectors:\n");
cannam@483:   printf("(First three; their definition in terms of original vbes.)\n");
cannam@483:   for (j = 0; j < m; j++) {
cannam@483:   for (i = 1; i <= 3; i++)  {
cannam@483:   printf("%12.4f", symmat[j][m-i]);  }
cannam@483:   printf("\n");  }
cannam@483: */
c@244: 
c@244: /* Form projections of row-points on prin. components. */
c@244: /* Store in 'data', overwriting original data. */
cannam@483:     for (i = 0; i < n; i++) {
cannam@483:         for (j = 0; j < m; j++) {
cannam@483:             interm[j] = data[i][j]; }   /* data[i][j] will be overwritten */
c@244:         for (k = 0; k < ncomponents; k++) {
cannam@483:             data[i][k] = 0.0;
cannam@483:             for (k2 = 0; k2 < m; k2++) {
cannam@483:                 data[i][k] += interm[k2] * symmat[k2][m-k-1]; }
c@244:         }
cannam@483:     }
c@244: 
cannam@483: /*      
cannam@483:         printf("\nProjections of row-points on first 3 prin. comps.:\n");
cannam@483:         for (i = 0; i < n; i++) {
cannam@483:         for (j = 0; j < 3; j++)  {
cannam@483:         printf("%12.4f", data[i][j]);  }
cannam@483:         printf("\n");  }
cannam@483: */
c@244: 
c@244: /* Form projections of col.-points on first three prin. components. */
c@244: /* Store in 'symmat2', overwriting what was stored in this. */
c@244: //for (j = 0; j < m; j++) {
cannam@483: //       for (k = 0; k < m; k++) {
cannam@483: //               interm[k] = symmat2[j][k]; }  /*symmat2[j][k] will be overwritten*/
c@244: //  for (i = 0; i < 3; i++) {
cannam@483: //      symmat2[j][i] = 0.0;
cannam@483: //              for (k2 = 0; k2 < m; k2++) {
cannam@483: //                      symmat2[j][i] += interm[k2] * symmat[k2][m-i-1]; }
cannam@483: //              if (evals[m-i-1] > 0.0005)   /* Guard against zero eigenvalue */
cannam@483: //                      symmat2[j][i] /= sqrt(evals[m-i-1]);   /* Rescale */
cannam@483: //              else
cannam@483: //                      symmat2[j][i] = 0.0;    /* Standard kludge */
c@244: //    }
c@244: // }
c@244: 
c@244: /*
cannam@483:   printf("\nProjections of column-points on first 3 prin. comps.:\n");
cannam@483:   for (j = 0; j < m; j++) {
cannam@483:   for (k = 0; k < 3; k++)  {
cannam@483:   printf("%12.4f", symmat2[j][k]);  }
cannam@483:   printf("\n");  }
cannam@483: */
c@244: 
c@244: 
cannam@483:     for (i = 0; i < m; i++)
cannam@483:         free(symmat[i]);
cannam@483:     free(symmat);
c@244: //FREE_ARRAY(symmat2,m);
cannam@483:     free(evals);
cannam@483:     free(interm);
c@244: 
c@244: }