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
  28                 vector<vector<double> > dCXYValues(numGroups);
  29
  30                 for(int i=0;i<numGroups;i++){
  31                         dCXYValues[i].resize(numGroups);
  32                         savedMins[i].resize(numGroups);
  33                         for(int j=0;j<numGroups;j++){
  34                                 if(i!=j){
  35                                         dCXYValues[i][j] = sCalculate(i,j);
  36                                         savedMins[i][j] = minXY;
  37                                 }
  38
  39                                 if(savedMins[i][i].size() == 0){
  40                                         savedMins[i][i] = minX;
  41                                 }
  42
  43                         }
  44                 }
  45                 return dCXYValues;
  46         }
  47         catch(exception& e) {
  48                 errorOut(e, "SLibshuff", "evaluateAll");
  49                 exit(1);
  50         }
  51 }
  52
  53 /***********************************************************************/
  54
  55 double SLibshuff::sCalculate(int x, int y){
  56         try{
  57                 minX = getMinX(x);
  58                 minXY = getMinXY(x,y);
  59
  60                 sort(minX.begin(), minX.end());
  61                 sort(minXY.begin(), minXY.end());
  62
  63                 double sum = 0.0,t=0.0;
  64                 int ix=0,iy=0;
  65                 while( (ix < groupSizes[x]) && (iy < groupSizes[x]) ) {
  66                         double h = (ix-iy)/double(groupSizes[x]);
  67
  68                         if(minX[ix] < minXY[iy]) {
  69                                 sum += (minX[ix] - t)*h*h;
  70                                 t = minX[ix++];
  71                         }
  72                         else {
  73                                 sum += (minXY[iy] - t)*h*h;
  74                                 t = minXY[iy++];
  75                         }
  76
  77                 }
  78
  79                 if(ix < groupSizes[x]) {
  80
  81                         while(ix < groupSizes[x]) {
  82                                 double h = (ix-iy)/double(groupSizes[x]);
  83                                 sum += (minX[ix] - t)*h*h;
  84                                 t = minX[ix++];
  85                         }
  86
  87                 }
  88                 else {
  89
  90                         while(iy < groupSizes[x]) {
  91                                 double h = (ix-iy)/double(groupSizes[x]);
  92                                 sum += (minXY[iy] - t)*h*h;
  93                                 t = minXY[iy++];
  94                         }
  95
  96                 }
  97
  98                 return sum;
  99         }
 100         catch(exception& e) {
 101                 errorOut(e, "SLibshuff", "sCalculate");
 102                 exit(1);
 103         }
 104 }
 105
 106 /***********************************************************************/