calculator.h

   1 #ifndef CALCULATOR_H
   2 #define CALCULATOR_H
   3
   4 using namespace std;
   5
   6 #include "mothur.h"
   7 #include "utilities.hpp"
   8 #include "sabundvector.hpp"
   9 #include "sharedsabundvector.h"
  10 #include "rabundvector.hpp"
  11 #include "uvest.h"
  12
  13 /* The calculator class is the parent class for all the different estimators implemented in mothur except the tree calculators.
  14 It has 2 pure functions EstOutput getValues(SAbundVector*), which works on a single group, and
  15 EstOutput getValues(SharedRAbundVector* shared1, SharedRAbundVector* shared2), which compares 2 groups. */
  16
  17
  18 using namespace std;
  19 typedef vector<double> EstOutput;
  20
  21 /***********************************************************************/
  22
  23 class Calculator {
  24
  25 public:
  26         Calculator(){};
  27         Calculator(string n, int c) : name(n), cols(c) {};
  28         virtual EstOutput getValues(SAbundVector*) = 0;
  29         virtual EstOutput getValues(SharedRAbundVector* shared1, SharedRAbundVector* shared2) = 0;
  30         virtual void print(ostream& f)  { f.setf(ios::fixed, ios::floatfield); f.setf(ios::showpoint);
  31                                                                           f << data[0]; for(int i=1;i<data.size();i++){ f << '\t' << data[i];   }}
  32         virtual string getName()                {       return name;    }
  33         virtual int getCols()           {       return cols;    }
  34 protected:
  35         EstOutput data;
  36         string name;
  37         int cols;
  38
  39 };
  40
  41 /**************************************************************************************************/
  42 /*This Class holds all of the methods that manipulate vectors.
  43 These methods are used in the other classes.
  44 This class must be included if any of the other classes are to be used.*/
  45
  46 class VecCalc
  47 {
  48         // The methods seen in the order here is how they are ordered throughout the class.
  49         public:
  50                 VecCalc(){};
  51                 void printElements(vector<double>); //This prints the values of the vector on one line with a space between each value.
  52                 void printElements(vector<string>); //This prints the values of the vector on one line with a space between each value.
  53                 int findString(vector<string>, string);//This returns the index of the given string in the given <string> vector, if the string does not exist in the vector it returns -1.
  54                 double mean(vector<double>); //This returns the mean value of the vector.
  55                 double stError(vector<double>); //This returns the standard error of the vector.
  56                 int sumElements(vector<int>, int);
  57                 int sumElements(vector<int>);
  58                 double sumElements(vector<double>); //This returns the sum of all the values in the vector.
  59                 double sumElements(vector<double>, int); //This returns the sum of all the values in the vector excluding those whose index is before the given index.
  60                 double findMax(vector<double>); //This returns the maximum value in the vector.
  61                 int numNZ(vector<int>); //This returns the number of non-zero values in the vector.
  62                 double numNZ(vector<double>); //This returns the number of non-zero values in the vector.
  63                 double numPos(vector<double>); //This returns the number of positive values in the vector.
  64                 double findMaxDiff(vector<double>, vector<double>); //This returns the absolute value of the maximum difference between the two vectors.
  65                 double findDStat(vector<double>, vector<double>, double); //This returns the D-Statistic of the two vectors with the given total number of species.
  66                 vector<int> findQuartiles(vector<double>); //This returns a vector with the first element being the index of the lower quartile of the vector and the second element being the index of the upper quartile of the vector.
  67                 vector<double> add(vector<double>, double); //This adds the given number to every element in the given vector and returns the new vector.
  68                 vector<double> multiply(vector<double>, double); //This multiplies every element in the given vector by the given number and returns the new vector.
  69                 vector<double> power(vector<double>, double); //This raises every element in the given vector to the given number and returns the new vector.
  70                 vector<double> addVecs(vector<double>,vector<double>); //The given vectors must be the same size. This adds the ith element of the first given vector to the ith element of the second given vector and returns the new vector.
  71                 vector<double> multVecs(vector<double>,vector<double>); //The given vectors must be the same size. This multiplies the ith element of the first given vector to the ith element of the second given vector and returns the new vector.
  72                 vector<double> remDup(vector<double>); //This returns a vector that contains 1 of each unique element in the given vector. The order of the elements is not changed.
  73                 vector<double> genCVec(vector<double>); //This returns a cumilative vector of the given vector. The ith element of the returned vector is the sum of all the elements in the given vector up to i.
  74                 vector<double> genRelVec(vector<double>); //This finds the sum of all the elements in the given vector and then divides the ith element in the given vector by that sum and then puts the result into a new vector, which is returned after all of the elements in the given vector have been used.
  75                 vector<double> genDiffVec(vector<double>, vector<double>);//This subtracts the ith element of the second given vector from the ith element of the first given vector and returns the new vector.
  76                 vector<double> genCSVec(vector<double>);//This calculates the number of species that have the same number of individuals as the ith element of the given vector and then returns a cumulative vector.
  77                 vector<double> genTotVec(vector<vector<double> >); //This adds up the ith element of all the columns and puts that value into a new vector. It those this for all the rows and then returns the new vector.
  78                 vector<double> quicksort(vector<double>); //This sorts the given vector from highest to lowest and returns the sorted vector.
  79                 vector<vector<double> > gen2DVec(vector<double>, int, int); //(vector, #rows/columns, 0 if the second parameter was rows, 1 if the second parameter was columns) Transforms a single vector that was formatted like a table into a 2D vector.
  80                 vector<string> getSData(char[]);//This takes a file name as a parameter and reads all of the data in the file into a <string> vector.
  81 };
  82
  83 /**************************************************************************************************/
  84 /*This Class contains methods that return the B Diverstiy of two sets
  85 of data. The four methods are the Whittaker's measure, the Marczewski-Stainhaus distance,
  86 the Sorensen quantitative index, and the Morisita-Horn index.
  87 The main method takes a number of columns of data and performs all 4 methods on each
  88 combination of columns. It prints a table for every method that shows the B Diverstiy for
  89 each combination. It also calculates the overall diversity for Whittaker's measure and
  90 the Marczewski-Steinhaus distance.*/
  91
  92
  93 /*class BDiversity
  94 {
  95         public:
  96                 void doBD(vector<double>, double);//Main method
  97                 double getWhitt(vector<double>,vector<double>);//Whittacker's measure
  98                 double getMS(vector<double>, vector<double>);//Marczewski-Stainhaus distance
  99                 double getSor(vector<double>, vector<double>);//Sorensen quantitative index
 100                 double getMor(vector<double>, vector<double>);//Morisita-Horn index
 101                 void printD(vector<vector<double> >, int);//This prints a table that represents the given 2D vector, the second paramter specifies which method is to be used (1 for Whitt, 2 for MS, 3 for Sor, and 4 for Mor)
 102 };*/
 103
 104 /**************************************************************************************************/
 105
 106 /*This Class is similar to the GeometricSeries.h class. It calculates
 107 the broken stick distribution of the table and prints the D-Statistic
 108 and the confidence limits for the Kolmogorov-Smirnov 1-Sample test
 109 with a 95% confidence level.*/
 110
 111 class BrokenStick
 112 {
 113         public:
 114                 void doBStick(vector<double>);
 115 };
 116
 117 /**************************************************************************************************/
 118 /*This Class calculates the geometric series distribution for the data.
 119 It prints the D-Statistic and the critical values for the Kolmogorov-Smirnov
 120 1-sample test at the 95% confidence interval.*/
 121
 122 /*class GeometricSeries
 123 {
 124         public:
 125                 void doGeomTest(vector<double>);
 126 };*/
 127
 128 /**************************************************************************************************/
 129 //This Class calculates the jackknifed estimate of the data and
 130 //prints it and the confidence limits at a chosen confidence level.
 131
 132 class Jackknifing
 133 {
 134         public:
 135                 void doJK(vector<double>, double);
 136 };
 137 /**************************************************************************************************/
 138 /*This Class stores calculates the Kolmogorov-Smirnov 2-Sample test between two samples.
 139 It prints the D-Statistic and the critical value for the test at
 140 the 90% and 95% confidence interval.*/
 141
 142 class KS2SampleTest
 143 {
 144         public:
 145                 void doKSTest(vector<double>, vector<double>);
 146 };
 147 /**************************************************************************************************/
 148 /*This Class calculates the Log Series Distribution for the data.
 149 It then generates a D-Statistic and prints the D-Statistic and
 150 the critical values for the Kolmogorov-Smirnov 1 sample test.*/
 151
 152 /*class LogSD
 153 {
 154         public:
 155                 void doLogSD(vector<double>, vector<double>);
 156 };*/
 157
 158 /**************************************************************************************************/
 159 //This Class calculates and prints the Q-Statistic for the data.
 160 class QStatistic
 161 {
 162         public:
 163                 void doQStat(vector<double>);
 164 };
 165 /**************************************************************************************************/
 166 class SSBPDiversityIndices
 167 {
 168         public:
 169                 void doSSBP(vector<double>);
 170                 double getShan(vector<double> vec);//The Shannon Index
 171                 double getSimp(vector<double> vec);//The Simpson Index
 172                 double getBP(vector<double> vec);//The Berger-Parker Index
 173 };
 174 /**************************************************************************************************/
 175 //This Class stores the table of the confidence limits of the Student-T distribution.
 176 class TDTable
 177 {
 178         public:
 179                 double getConfLimit(int,int);
 180 };
 181
 182 /**************************************************************************************************/
 183 //This Class stores the table of the confidence limits of the One-Sample Kolmogorov-Smirnov Test.
 184 class KOSTable
 185 {
 186         public:
 187                 double getConfLimit(int);
 188 };
 189
 190 /**************************************************************************************************/
 191 /*This Class calculates the truncated lognormal for the data.
 192 It then prints the D-Statistic and the critical values for the
 193 Kolmogorov-Smirnov 1-Sample test.*
 194
 195 class TrunLN
 196 {
 197         public:
 198                 void doTrunLN(vector<double>, vector<double>);
 199 };
 200 /**************************************************************************************************/
 201
 202 #endif
 203