Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages

BasicStatistics.h (Maintainer: Clemens Groepl)

Go to the documentation of this file.
00001 // -*- Mode: C++; tab-width: 2; -*-
00002 // vi: set ts=2:
00003 //
00004 // --------------------------------------------------------------------------
00005 //                   OpenMS Mass Spectrometry Framework
00006 // --------------------------------------------------------------------------
00007 //  Copyright (C) 2003-2008 -- Oliver Kohlbacher, Knut Reinert
00008 //
00009 //  This library is free software; you can redistribute it and/or
00010 //  modify it under the terms of the GNU Lesser General Public
00011 //  License as published by the Free Software Foundation; either
00012 //  version 2.1 of the License, or (at your option) any later version.
00013 //
00014 //  This library is distributed in the hope that it will be useful,
00015 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 //  Lesser General Public License for more details.
00018 //
00019 //  You should have received a copy of the GNU Lesser General Public
00020 //  License along with this library; if not, write to the Free Software
00021 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 //
00023 // --------------------------------------------------------------------------
00024 // $Maintainer: Clemens Groepl $
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         // precondition size == probability.size() is guaranteed by wrappers.
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   } // namespace Math
00301 
00302 } // namespace OpenMS
00303 
00304 #endif // OPENMS_MATH_STATISTICS_BASICSTATISTICS_H

Generated Tue Apr 1 15:36:33 2008 -- using doxygen 1.5.4 OpenMS / TOPP 1.1