histograms.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_MATH_STATS_HISTOGRAMS_H
#define ELEMENTA_MATH_STATS_HISTOGRAMS_H
 
#include <string>
#include <cmath>
#include <vector>
#include <iterator>
#include <algorithm>
#include "elementa/base/exceptions.h"
#include "elementa/math/stats/statistic.h"
 
namespace elementa
{
 
namespace math
{
 
namespace stats
{
 
/* *****************************************************************************
*
*   Class: Histogram
*
*******************************************************************************/
 
class Histogram
{
 public:
 
 
    class BinDef: std::vector< double >
    {
     public:
 
 
        static size_t eq_freq_nbins(size_t ndata) 
            { return(static_cast<size_t>(
                        std::round( 2.0 * std::pow(static_cast<double>(ndata),
                                                   2.0/5.0)))); }
 
 
        BinDef(void):numbins_{1} {}
 
 
        BinDef(double leftmost, double binwidth_or_rightmost, size_t numbins,
               bool iswidthorright = true,
               bool addleftinf = false, bool addrightinf = false);
 
 
        BinDef(long leftcenter, long rightcenter,
               bool addleftinf = false, bool addrightinf = false);
 
 
        size_t numbins(void) const noexcept { return(numbins_); }
 
 
        bool entireReals(void) const noexcept { return(binlefts_.empty()); }
 
 
        void binBounds(size_t ind, double & left, double & right) const;
 
        /* Return FALSE if V does not fall within any bin.
        IND is filled with an index that is from 0 for the leftmost bin 
        (including the left infinite one if any) to numbins()-1 for the 
        rightmost one (including the right infinite if any). */
        bool whichBin(double v, size_t & ind) const noexcept;
 
        std::string to_string(void) const;
 
     private:
 
        static void checkFiniteness(double v, const std::string & name,
                                    const std::string & place);
        static void checkPositiveness(double v, const std::string & name,
                                      const std::string & place, 
                                      bool orzero = false);
        static void checkNumbins(size_t numbins, const std::string & place);
 
        std::vector<double> binlefts_; 
        double rightmost_; 
        bool tominf_,topinf_; 
        size_t numbins_;
 
        size_t calcnumbins(void) const noexcept
            { if (binlefts_.empty()) return(1);
              return(binlefts_.size() + (tominf_ ? 1:0) + (topinf_ ? 1:0)); }
    };
 
 
    template <class DIt>
    Histogram(const DIt & first, const DIt & pastend,
              const BinDef & bindef, 
              const GetStaDatumFun<DIt> & getdatum = getstadatum_direct<DIt>);
 
    const BinDef & bindef(void) const { return(*bindef_); }
 
    size_t numData(void) const noexcept { return(ndata_); }
 
 
    size_t freq(size_t indbin) const
        { if (indbin >= frequencies_.size()) ELE_CODE_OUTOFRANGE("");
          return(frequencies_[indbin]); }
 
    std::string to_string(void) const;
 
 private:
 
    const BinDef * bindef_;
    std::vector<size_t> frequencies_; 
    size_t ndata_;
};
 
 
 
/* ===========================================================================
 
        ========== IMPLEMENTATION OF TEMPLATES ==========
 
============================================================================= */
 
 
/* *****************************************************************************
*
*   Class: Histogram
*
*******************************************************************************/
 
template <class DIt>
Histogram::Histogram(const DIt & first, const DIt & pastend,
                     const BinDef & bindef, 
                     const GetStaDatumFun<DIt> & getdatum)
{
    if (first == pastend) ELE_CODE_INVARG("No data to form histogram");
    bindef_ = & bindef;
    if (bindef.entireReals())
    {
        ndata_ = std::distance(first,pastend);
        frequencies_.push_back(ndata_);
    }
    else
    {
        ndata_ = 0;
        frequencies_ = std::vector<size_t>(bindef.numbins(),0);
        auto it{first};
        size_t ind;
        while (it != pastend)
        {
            if (bindef.whichBin(getdatum(it),ind)) 
            {
                ++(frequencies_[ind]);
                ++ndata_;
            }
            ++it;
        }
    }
}
 
} // end stats namespace
 
} // end math namespace
 
} // end elementa namespace
 
 
#endif