File: StatisticsUtilities.h

package info (click to toggle)
caret 5.6.4~dfsg.1-3
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, wheezy
  • size: 31,904 kB
  • ctags: 28,901
  • sloc: cpp: 378,050; python: 6,718; ansic: 5,507; makefile: 333; sh: 46
file content (157 lines) | stat: -rw-r--r-- 5,240 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

#ifndef __STATISTICS_UTILITIES_H__
#define __STATISTICS_UTILITIES_H__

/*LICENSE_START*/
/*
 *  Copyright 1995-2002 Washington University School of Medicine
 *
 *  http://brainmap.wustl.edu
 *
 *  This file is part of CARET.
 *
 *  CARET is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  CARET is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with CARET; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*LICENSE_END*/

#include <vector>

/// This class contains static methods for performing statisical computations
class StatisticsUtilities {
   public:
      /// class for holding statistics results
      class DescriptiveStatistics {
         public:
            /// Constructor
            DescriptiveStatistics();
            
            /// Destructor
            ~DescriptiveStatistics();
            
            /// reset all members
            void reset();
            
            /// average of values
            float average;
            
            /// standard deviation of values
            float standardDeviation;
            
            /// standard error (dev / sqrt(num - 1))
            float standardError;
            
            /// most positive value
            float mostPositiveValue;
            
            /// least positive value
            float leastPositiveValue;
            
            /// most negative value
            float mostNegativeValue;
            
            /// least negative value
            float leastNegativeValue;
            
            /// average of absolute values
            float absAverage;
            
            /// standard deviation of absolute values
            float absStandardDeviation;
            
            /// standard error (dev / sqrt(num - 1)) of absolute values
            float absStandardError;
            
            /// minimum value
            float minValue;
            
            /// maximum value
            float maxValue;
            
            /// range of values
            float range;
            
            /// median value
            float median;
            
            /// median of absolute values
            float absMedian;
            
            /// average of values with top and bottom 2% excluded
            float average96;
            
            /// standard deviation of values with top and bottom 2% excluded
            float standardDeviation96;
            
            /// standard error (dev / sqrt(num - 1)) with top and bottom 2% excluded
            float standardError96;
            
            /// most positive value
            float mostPositiveValue96;
            
            /// least positive value
            float leastPositiveValue96;
            
            /// most negative value
            float mostNegativeValue96;
            
            /// least negative value
            float leastNegativeValue96;
            
            /// average of absolute values with top and bottom 2% excluded
            float absAverage96;
            
            /// standard deviation of absolute values with top and bottom 2% excluded
            float absStandardDeviation96;
            
            /// standard error (dev / sqrt(num - 1)) of absolute valueswith top and bottom 2% excluded
            float absStandardError96;
            
            /// minimum value with top and bottom 2% excluded
            float minValue96;
            
            /// maximum value with top and bottom 2% excluded
            float maxValue96;
            
            /// range of values with top and bottom 2% excluded
            float range96;
            
            /// median value with top and bottom 2% excluded
            float median96;            
            
            /// median of absolute values with top and bottom 2% excluded
            float absMedian96;            

            /// the "96%" values (top and bottom 2% excluded)
            std::vector<float> values96Percent;
      };
      
      // determine statistics for a set of values
      static void computeStatistics(const std::vector<float>& valuesIn,
                                    const bool dataIsSampleFlag,
                                    DescriptiveStatistics& statisticsOut);
      
      
   protected:      
      // compute statistics helper
      static void computeStatisticsHelper(const std::vector<float>& valuesIn,
                                          const bool do96Percent,
                                          const bool dataIsSampleFlag,
                                          DescriptiveStatistics& statisticsOut);
                                          
};

#endif // __STATISTICS_UTILITIES_H__