Statistic.ih

#include <cstdlib>
#include <iostream>
#include <algorithm>

// Implementation of inline methods                                          //
template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType>::~Statistic()
{}

template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType>::Statistic(bool storeSample)
  : mySamples( 0 ), myExp( 0 ), myExp2( 0 ),  myMax( 0 ),myMin( 0 ), myMedian(0),  myStoreSamples (storeSample),
    myIsTerminated(false)
{
  myValues=  std::vector<RealNumberType> ();
}

template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType>::Statistic
( const Statistic<RealNumberType> & other )
  : mySamples( other.mySamples ), 
    myExp( other.myExp ), 
    myExp2( other.myExp2 ), 
    myMax( other.myMax ),
    myMin( other.myMin ), 
    myMedian( other.myMedian), 
    myStoreSamples (other.myStoreSamples),
    myIsTerminated(other.myIsTerminated)
{
  if(myStoreSamples){
    myValues=  std::vector<RealNumberType> ();
    for(unsigned int i=0; i<other.myValues.size(); i++){
      myValues.push_back(other.myValues.at(i));
    }
  }
  
}

template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType> & 
DGtal::Statistic<RealNumberType>::operator=
( const Statistic<RealNumberType> & other )
{
  if ( this != &other )
    {
      mySamples = other.mySamples;
      myExp = other.myExp;
      myExp2 = other.myExp2;
      myMin = other.myMin;
      myMax = other.myMax;
      myMedian = other.myMedian;
      myStoreSamples = other.myStoreSamples;
      myIsTerminated=other.myIsTerminated;
      if(myStoreSamples){
  myValues=  std::vector<RealNumberType> ();
  for(unsigned int i=0; i<other.myValues.size(); i++){
    myValues.push_back(other.myValues.at(i));
  }
      }
      
    }
  return *this;
}
 

template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType> & 
DGtal::Statistic<RealNumberType>::operator+=
( const Statistic<RealNumberType> & other )
{
  if ( other.mySamples != 0 )
    {
      if ( ( mySamples == 0 ) || ( other.myMin < myMin ) )
  myMin = other.myMin;
      if ( ( mySamples == 0 ) || ( other.myMax > myMax ) )
  myMax = other.myMax;
    }
  mySamples += other.mySamples;
  myExp += other.myExp;
  myExp2 += other.myExp2;
  myIsTerminated=false;
  
  if(myStoreSamples && other.myStoreSamples){
    for(unsigned int i=0; i<other.myValues.size(); i++){
      myValues.push_back(other.myValues.at(i));
    }
  }else{
    myStoreSamples=false;
  }
  
}





template <typename RealNumberType>
inline
DGtal::Statistic<RealNumberType> 
DGtal::Statistic<RealNumberType>::operator+
( const Statistic<RealNumberType> & other ) const
{
  Statistic<RealNumberType> stat( *this );
  stat += other;
  return stat;
}






// ----------------------- Accessors ------------------------------

template <typename RealNumberType>
inline
unsigned int 
DGtal::Statistic<RealNumberType>::samples() const
{
  return mySamples;
}

template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::mean() const
{
  return myExp / (RealNumberType) mySamples;
}

template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::variance() const
{
  return ( myExp2 / (RealNumberType) mySamples ) - mean() * mean();
}

template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::unbiasedVariance() const
{
  ASSERT( mySamples != 0 );
  return ( (RealNumberType) mySamples ) * variance() 
    / ( (RealNumberType) mySamples );
}

template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::max() const
{
  return myMax;
}

template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::min() const
{
  return myMin;
}



template <typename RealNumberType>
inline
RealNumberType
DGtal::Statistic<RealNumberType>::median() 
{
  ASSERT( myStoreSamples || myIsTerminated );
  if(myIsTerminated){
    return myMedian;
  }
  else{
    nth_element( myValues.begin(), myValues.begin()+(myValues.size()/2), 
     myValues.end());
    return *(myValues.begin()+(myValues.size()/2));
  }
}


template <typename RealNumberType>
inline
void 
DGtal::Statistic<RealNumberType>::addValue( RealNumberType v )
{
  if ( mySamples == 0 )
    {
      myMin = v;
      myMax = v;
    }
  else if ( v < myMin ) myMin = v;
  else if ( v > myMax ) myMax = v;
  myExp += v;
  myExp2 += v * v;
  ++mySamples;
  if(myStoreSamples){
    myValues.push_back(v);
  }
}
  
template <typename RealNumberType>
template <class Iter>
inline
void 
DGtal::Statistic<RealNumberType>::addValues( Iter b, Iter e )
{
  for ( ; b != e; ++b )
    addValue( *b );
}

template <typename RealNumberType>
inline
void
DGtal::Statistic<RealNumberType>::clear()
{
  mySamples = 0;
  myExp = 0;
  myExp2 = 0;
  myMin = 0;
  myMax = 0;
  myMedian=0;
  myIsTerminated=false;
  if(myStoreSamples){
    myValues.clear();
  }
}




template< typename RealNumberType> 
inline
void 
DGtal::Statistic<RealNumberType>::terminate()
{
  if(myStoreSamples){
    myMedian=median();
    myValues.clear();
    myStoreSamples=false;
    myIsTerminated=true;
  } 
}
 

// Interface - public :

template <typename RealNumberType>
inline
void 
DGtal::Statistic<RealNumberType>::selfDisplay
( std::ostream& thatStream ) const
{
  thatStream << "[Statistic "
       << " nb=" << samples()
       << " exp=" << mean()
       << " var=" << variance()
       << " uvar=" << unbiasedVariance()
       << " min=" << min()
       << " max=" << max()
       << "]";
}

template <typename RealNumberType>
inline
bool 
DGtal::Statistic<RealNumberType>::OK() const
{
  return true;
}


// Implementation of inline functions and external operators                 //

template <typename RealNumberType>
inline
std::ostream&
DGtal::operator<<( std::ostream & thatStream, 
       const Statistic<RealNumberType> & that_object_to_display )
{
  that_object_to_display.selfDisplay( thatStream );
  return thatStream;
}

//                                                                           //