Histogram.h

 
#pragma once

 
#if defined(Histogram_RECURSES)
#error Recursive header files inclusion detected in Histogram.h
#else // defined(Histogram_RECURSES)
#define Histogram_RECURSES
 
#if !defined Histogram_h
#define Histogram_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Clone.h"
#include "DGtal/math/CBinner.h"
#include "DGtal/kernel/CEuclideanRing.h"
#include "DGtal/math/Statistic.h"
 
namespace DGtal
{
  template <typename TQuantity>
  struct RegularBinner {
    typedef TQuantity Quantity;
    typedef RegularBinner< Quantity > Self;
    typedef DGtal::uint32_t Bin;
 
    Quantity myMin; 
    Quantity myMax; 
    Bin myNb;       
    Quantity myWidth;

    RegularBinner( const Quantity & min, const Quantity & max, Bin n )
      : myMin( min ), myMax( max ), myNb( n )
    {
      ASSERT( max > min );
      ASSERT( n > 0 );
      myWidth = ( max - min ) / static_cast<Quantity>( n );
    }

    inline Bin size() const
    {
      return myNb;
    }

    inline Bin operator()( const Quantity & q ) const
    {
      if ( q <= myMin )      return NumberTraits<Bin>::ZERO;
      else if ( q >= myMax ) return myNb - NumberTraits<Bin>::ONE;
      else return static_cast<Bin>( floor( NumberTraits<Quantity>::castToDouble( ( q - myMin ) / myWidth ) ) );
    }
  };

  // template class Histogram
  template < typename TQuantity,
             typename TBinner = RegularBinner< TQuantity > >
  class Histogram
  {
  public:
    BOOST_CONCEPT_ASSERT(( concepts::CEuclideanRing< TQuantity > ));
    BOOST_CONCEPT_ASSERT(( concepts::CBinner< TBinner > ));
    BOOST_STATIC_ASSERT(( boost::is_same< TQuantity, typename TBinner::Quantity >::value ));
 
    // ----------------------- public types ------------------------------
  public:
    typedef TQuantity Quantity;
    typedef TBinner Binner;
    typedef Histogram< Quantity, Binner > Self;
    typedef typename Binner::Bin Bin;
    typedef DGtal::uint64_t Size;
    typedef std::vector<Size> Container;
    typedef Container::const_iterator ConstIterator;

    enum Formula { SquareRoot ,
                   Sturges ,
                   Rice ,
                   Scott  };
    // ----------------------- Standard services ------------------------------
  public:

    ~Histogram();

    Histogram();

    void clear();

    void init( Clone<Binner> binner );

    void init( Formula formula, const Statistic<Quantity> & stat );

    void init( Bin nbBins, const Statistic<Quantity> & stat );

    void addValue( Quantity q );

    template <typename TInputIterator>
    void addValues( TInputIterator it, TInputIterator itE );

    void terminate();

    Bin bin( Quantity q ) const;

    Bin size() const;

    Size area() const;

    Size nb( Bin b ) const;

    Size accumulation( Bin b ) const;

    double pdf( Bin b ) const;

    double cdf( Bin b ) const;
 
    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;
 
    // ------------------------- Protected Data ------------------------------
  protected:
    const Binner* myBinner;
    Container myHistogram;
    Container myCumulativeHistogram;
 
    // ------------------------- Private Data --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  private:

    Histogram ( const Histogram & other );

    Histogram & operator= ( const Histogram & other );
 
    // ------------------------- Internals ------------------------------------
  private:
    void prepare( Bin size );
 
 
  }; // end of class Histogram
 

  template <typename TQuantity, typename TBinner>
  std::ostream&
  operator<< ( std::ostream & out, const Histogram<TQuantity, TBinner> & object );
 
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/math/Histogram.ih"
 
//                                                                           //
 
#endif // !defined Histogram_h
 
#undef Histogram_RECURSES
#endif // else defined(Histogram_RECURSES)