00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef OPENMS_MATH_STATISTICS_BASICSTATISTICS_H
00028 #define OPENMS_MATH_STATISTICS_BASICSTATISTICS_H
00029
00030 #include <OpenMS/CONCEPT/Types.h>
00031 #include <OpenMS/CONCEPT/Exception.h>
00032 #include <vector>
00033 #include <ostream>
00034 #include <cmath>
00035 #include <numeric>
00036
00037 namespace OpenMS
00038 {
00039 namespace Math
00040 {
00041
00060 template < typename RealT = double >
00061 class
00062 BasicStatistics
00063 {
00064
00065 public:
00066
00068 typedef RealT RealType;
00069
00070 typedef std::vector < RealType > probability_container;
00071 typedef std::vector < RealType > coordinate_container;
00072
00074 BasicStatistics ()
00075 : mean_(0),
00076 variance_(0),
00077 sum_(0)
00078 {}
00079
00081 BasicStatistics ( BasicStatistics const & arg )
00082 : mean_(arg.mean_),
00083 variance_(arg.variance_),
00084 sum_(arg.sum_)
00085 {}
00086
00088 BasicStatistics & operator = ( BasicStatistics const & arg )
00089 {
00090 mean_ = arg.mean_;
00091 variance_ = arg.variance_;
00092 sum_ = arg.sum_;
00093 return *this;
00094 }
00095
00097 void clear ()
00098 {
00099 mean_ = 0;
00100 variance_ = 0;
00101 sum_ = 0;
00102 }
00103
00105
00106 template < typename ProbabilityIterator >
00107 void update ( ProbabilityIterator probability_begin,
00108 ProbabilityIterator const probability_end
00109 )
00110 {
00111 clear();
00112 unsigned pos = 0;
00113 ProbabilityIterator iter = probability_begin;
00114
00115 for ( ; iter != probability_end; ++iter, ++pos )
00116 {
00117 sum_ += *iter;
00118 mean_ += *iter * pos;
00119 }
00120 mean_ /= sum_;
00121
00122 for ( iter = probability_begin, pos = 0; iter != probability_end; ++iter, ++pos )
00123 {
00124 RealType diff = RealType(pos) - mean_;
00125 diff *= diff;
00126 variance_ += *iter * diff;
00127 }
00128 variance_ /= sum_;
00129 }
00130
00132
00133 template < typename ProbabilityIterator, typename CoordinateIterator >
00134 void update ( ProbabilityIterator const probability_begin,
00135 ProbabilityIterator const probability_end,
00136 CoordinateIterator const coordinate_begin
00137 )
00138 {
00139 clear();
00140 ProbabilityIterator prob_iter = probability_begin;
00141 CoordinateIterator coord_iter = coordinate_begin;
00142
00143 for ( ; prob_iter != probability_end; ++prob_iter, ++coord_iter )
00144 {
00145 sum_ += *prob_iter;
00146 mean_ += *prob_iter * *coord_iter;
00147 }
00148 mean_ /= sum_;
00149
00150 for ( prob_iter = probability_begin, coord_iter = coordinate_begin;
00151 prob_iter != probability_end;
00152 ++prob_iter, ++coord_iter
00153 )
00154 {
00155 RealType diff = *coord_iter - mean_;
00156 diff *= diff;
00157 variance_ += *prob_iter * diff;
00158 }
00159 variance_ /= sum_;
00160 return;
00161 }
00162
00164 RealType mean () const { return mean_; }
00165 void setMean ( RealType const & mean ) { mean_ = mean; }
00166
00168 RealType variance() const { return variance_; }
00169 void setVariance ( RealType const & variance ) { variance_ = variance; }
00170
00172 RealType sum() const { return sum_; }
00173 void setSum ( RealType const & sum ) { sum_ = sum; }
00174
00175
00180 RealType normalDensity_sqrt2pi ( RealType coordinate ) const throw()
00181 {
00182 coordinate -= mean();
00183 coordinate *= coordinate;
00184 return exp ( - coordinate / RealType(2) / variance() );
00185 }
00186
00188 static RealType sqrt2pi () { return 2.50662827463100050240; }
00189
00193 inline RealType normalDensity ( RealType const coordinate ) const throw()
00194 {
00195 return normalDensity_sqrt2pi ( coordinate ) / sqrt2pi() ;
00196 }
00197
00202 void normalApproximation ( probability_container & probability )
00203 {
00204 normalApproximationHelper_ ( probability, probability.size() );
00205 return;
00206 }
00207
00212 void normalApproximation ( probability_container & probability,
00213 typename probability_container::size_type const size
00214 )
00215 {
00216 probability.resize ( size );
00217 normalApproximationHelper_ ( probability, size );
00218 return;
00219 }
00220
00226 void normalApproximation ( probability_container & probability,
00227 coordinate_container const & coordinate
00228 )
00229 {
00230 probability.resize ( coordinate.size() );
00231 normalApproximationHelper_ ( probability, coordinate );
00232 return;
00233 }
00234
00239 friend std::ostream & operator << ( std::ostream & os, BasicStatistics & arg )
00240 {
00241 os << "BasicStatistics: mean=" << arg.mean() << " variance=" << arg.variance() << " sum=" << arg.sum();
00242 return os;
00243 }
00244
00245 protected:
00246
00248
00249
00250 RealType mean_;
00251 RealType variance_;
00252 RealType sum_;
00253
00254 private:
00256
00258
00259
00260 void normalApproximationHelper_ ( probability_container & probability,
00261 typename probability_container::size_type const size
00262 )
00263 {
00264 RealType gaussSum = 0;
00265 typename coordinate_container::size_type i;
00266
00267
00268 for ( i = 0; i < size; ++i ) {
00269 gaussSum += normalDensity_sqrt2pi ( i );
00270 }
00271
00272 for ( i = 0; i < size; ++i ) {
00273 probability [ i ] = normalDensity_sqrt2pi ( i ) / gaussSum * sum();
00274 }
00275 return;
00276 }
00277
00278 void normalApproximationHelper_ ( probability_container & probability,
00279 coordinate_container const & coordinate
00280 )
00281 {
00282 RealType gaussSum = 0;
00283 typename coordinate_container::size_type i;
00284 typename coordinate_container::size_type const size = coordinate.size();
00285
00286 for ( i = 0; i < size; ++i ) {
00287 gaussSum += normalDensity_sqrt2pi ( coordinate[i] );
00288 }
00289
00290 for ( i = 0; i < size; ++i ) {
00291 probability [ i ] = normalDensity_sqrt2pi ( coordinate[i] ) / gaussSum * sum();
00292 }
00293 return;
00294 }
00295
00297
00298 };
00299
00300 }
00301
00302 }
00303
00304 #endif // OPENMS_MATH_STATISTICS_BASICSTATISTICS_H