slibshuff.cpp

   1 /*
   2  *  slibshuff.cpp
   3  *  Mothur
   4  *
   5  *  Created by Pat Schloss on 4/8/09.
   6  *  Copyright 2009 Patrick D. Schloss. All rights reserved.
   7  *
   8  */
   9
  10 #include "slibshuff.h"
  11
  12 /***********************************************************************/
  13
  14 SLibshuff::SLibshuff(FullMatrix* D, int it, float co) : Libshuff(D, it, 0, co){}
  15
  16 /***********************************************************************/
  17
  18 float SLibshuff::evaluatePair(int i, int j){
  19         return sCalculate(i,j);
  20 }
  21
  22 /***********************************************************************/
  23
  24 vector<vector<double> > SLibshuff::evaluateAll(){
  25         try{
  26                 savedMins.resize(numGroups);
  27                 vector<vector<double> > dCXYValues(numGroups);
  28
  29                 for(int i=0;i<numGroups;i++){
  30                         dCXYValues[i].resize(numGroups);
  31                         savedMins[i].resize(numGroups);
  32                         for(int j=0;j<numGroups;j++){
  33                                 if(i!=j){
  34                                         dCXYValues[i][j] = sCalculate(i,j);
  35                                         savedMins[i][j] = minXY;
  36                                 }
  37
  38                                 if(savedMins[i][i].size() == 0){
  39                                         savedMins[i][i] = minX;
  40                                 }
  41
  42                         }
  43                 }
  44                 return dCXYValues;
  45         }
  46         catch(exception& e) {
  47                 errorOut(e, "SLibshuff", "evaluateAll");
  48                 exit(1);
  49         }
  50 }
  51
  52 /***********************************************************************/
  53
  54 double SLibshuff::sCalculate(int x, int y){
  55         try{
  56                 minX = getMinX(x);
  57                 minXY = getMinXY(x,y);
  58
  59                 sort(minX.begin(), minX.end());
  60                 sort(minXY.begin(), minXY.end());
  61
  62                 double sum = 0.0,t=0.0;
  63                 int ix=0,iy=0;
  64                 while( (ix < groupSizes[x]) && (iy < groupSizes[x]) ) {
  65                         double h = (ix-iy)/double(groupSizes[x]);
  66
  67                         if(minX[ix] < minXY[iy]) {
  68                                 sum += (minX[ix] - t)*h*h;
  69                                 t = minX[ix++];
  70                         }
  71                         else {
  72                                 sum += (minXY[iy] - t)*h*h;
  73                                 t = minXY[iy++];
  74                         }
  75
  76                 }
  77
  78                 if(ix < groupSizes[x]) {
  79
  80                         while(ix < groupSizes[x]) {
  81                                 double h = (ix-iy)/double(groupSizes[x]);
  82                                 sum += (minX[ix] - t)*h*h;
  83                                 t = minX[ix++];
  84                         }
  85
  86                 }
  87                 else {
  88
  89                         while(iy < groupSizes[x]) {
  90                                 double h = (ix-iy)/double(groupSizes[x]);
  91                                 sum += (minXY[iy] - t)*h*h;
  92                                 t = minXY[iy++];
  93                         }
  94
  95                 }
  96
  97                 return sum;
  98         }
  99         catch(exception& e) {
 100                 errorOut(e, "SLibshuff", "sCalculate");
 101                 exit(1);
 102         }
 103 }
 104
 105 /***********************************************************************/