---

histogram.h

Go to the documentation of this file.

#ifndef _HISTOGRAM_H_
#define _HISTOGRAM_H_

#include <assert.h>

class histogram
{
private:
  // copy constructor
  histogram( const histogram &rhs );

  class bin_vec;
  void init_bins( bin_vec &bins,
                  const double min,
                  const double max );

  class value_pool
  {
  private:
    size_t ix_;
    const double *vec_;
    const size_t N_;

  public:
    value_pool( const double *vec, size_t N ) : vec_( vec ), N_( N )
    {
      ix_ = 0;
    }

    bool get_val( double &val )
    {
      bool rslt = false;
      val = 0.0;
      if (ix_ < N_) {
        rslt = true;
        val = vec_[ ix_ ];
        ix_++;
      }
      return rslt;
    } // get_val

  }; // value_pool

public:
  class histo_bin
  {
  private:
    double frequency_;
    double start_;
    double end_;

  public:
    histo_bin() {}
    ~histo_bin() {}

    double frequency() { return frequency_; }
    void frequency( const double f ) { frequency_ = f; }

    double &freqPtr() { return frequency_; }

    double start() { return start_; }
    void start( const double s ) { start_ = s; }

    double end() { return end_; }
    void end( const double e ) { end_ = e; }

  }; // class histo_bin


  class bin_vec
  {
  private:
    bin_vec( const bin_vec &rhs );
    const size_t num_bins;
    histo_bin *bins;

  public:
    bin_vec( size_t N ) : num_bins( N )
    {
      bins = new histo_bin[ num_bins ];
    }

    ~bin_vec()
    {
      delete [] bins;
    }

    size_t length() { return num_bins; }

    double start( const size_t i ) 
    { 
      assert( i < num_bins );
      return bins[i].start(); 
    }

    void start( const size_t i, const double val )
    {
      assert( i < num_bins );
      bins[i].start( val );
    }

    double end( const size_t i ) 
    { 
      assert( i < num_bins );
      return bins[i].end(); 
    }

    void end( const size_t i, const double val )
    {
      assert( i < num_bins );
      bins[i].end( val );
    }

    double &operator[]( const size_t i )
    {
      assert( i < num_bins );
      
      return bins[i].freqPtr();
    }

    double operator[]( const size_t i ) const
    {
      assert( i < num_bins );
      return bins[i].frequency();
    }

  }; // class bin_vec

public:
  histogram() {}
  ~histogram() {}

  void calculate( const double *raw_data,
                  const size_t N,
                  bin_vec &binz );
}; // histogram


#endif

---