html/stable/HistoStats_8hpp_source.html

#pragma once


#include "opals/config.hpp"

#include "opals/String.hpp"

#include "opals/Array.hpp"

#include "opals/Vector.hpp"

#include "opals/HistoMode.hpp"


namespace opals {


  /// \brief  HistoStats provides a histogram and additional statistical measures.

  ///

  /// HistoStats provides a histogram and additional statistical measures like

  /// min, max, mean, median ... of certain data sample.

  /// The histogram in particular is stored as a std::vector of std:pairs, each of which

  /// stores the data of a single histogram bin (class) with its lower

  /// boundary (first) and relative frequency (second). The first bin

  /// contains all underflow values, followed by the regular bins of

  /// constant width. The last class contains all overflow values. Absolute

  /// frequencies can be obtained by multiplying the relative frequencies

  /// with the total number of samples (countUsed). Additionally, several

  /// standard statistical values are provided (min, max, mean, median...)

  ///

  /// \author GM

  /// \date   12.06.2010

  class OPALS_API HistoStats

  {

  public:

    /// vector of double pairs

    typedef opals::Vector< std::pair< double, double > > PairOfDblVec;

    typedef opals::Vector< std::pair< double, uint64_t > > DblInt64Vec;


    /// vector of histogram bins stored as std::pair

    /** first: lower bound of bin, second: absolute or relative frequency */

    typedef DblInt64Vec   AbsBinVector;

    typedef PairOfDblVec  RelBinVector;


    typedef RelBinVector  BinVector;  ///deprecated: use AbsBinVector or RelBinVector instead


    /// vector of quantiles

    /** first: probabilities (double: 0 <= p <= 1), second: according quantiles */

    typedef PairOfDblVec QuantileVector;


  public:

    HistoStats();

    virtual ~HistoStats();


    /// access functions

    void setHistoStats( const long long &CountData,

                        const long long &CountUsed,

                        const double &Min, const double &Max, const double &Mean,

                        const double &Median, const double &Mode,

                        const double &StdDev, const double &Rms,

                        const double &StdDevMAD, const double &Skewness,

                        const opals::HistoMode &CalcMode,

                        const QuantileVector &Quantiles, const AbsBinVector &Bins, const double &BinWidth);

    void setCountData( const double &Count ) { countData = Count; }

    void setCountUsed( const double &Count ) { countUsed = Count; }

    void setMin( const double &Min ) { min = Min; }

    void setMax( const double &Max ) { max = Max; }

    void setMean( const double &Mean ) { mean = Mean; }

    void setMedian( const double &Median ) { median = Median; }

    void setMode(const double &Mode) { mode = Mode; }

    void setStdDev( const double &StdDev) { stdDev = StdDev; }

    void setRms( const double &Rms) { rms = Rms; }

    void setStdDevMAD( const double &StdDev) { stdDev = StdDev; }

    void setSkewness( const double &Skewness ) { skewness = Skewness; }

    void setQuantiles( const QuantileVector &Quantiles ) { quantiles = Quantiles; }

    void setAbsBins( const AbsBinVector &Bins ) { bins = Bins; }

    void setBinWidth( const double &BinWidth) { binWidth = BinWidth; }

    void setCalcMode( const opals::HistoMode CalcMode) { calcMode  = CalcMode; }

    void setLabel( const opals::String &Label ) { label = Label; }

    void setExactComputation(bool flag) { exactComputation = flag;  }


    /// query functions

    long long getCountData() const { return countData; }

    long long getCountUsed() const { return countUsed; }

    double getMin() const { return min; }

    double getMax() const { return max; }

    double getMean() const{ return mean; }

    double getMedian() const { return median; }

    double getMode() const   { return mode; }

    double getStdDev() const { return stdDev; }

    double getRms() const { return rms; }

    double getStdDevMAD() const { return stdDevMAD; }

    double getSkewness() const { return skewness; }

    QuantileVector getQuantiles() const { return quantiles; }

    AbsBinVector getAbsBins() const { return bins; }    ///< get bin vector with absolute frequency values

    RelBinVector getRelBins() const;                    ///< get bin vector with relative frequency values

    double getBinWidth()      const { return binWidth; }

    opals::HistoMode  getCalcMode() const { return calcMode; }

    const opals::String& getLabel() const { return label; }

    bool getExactComputation() const { return exactComputation; }


    BinVector getBins() const { return getRelBins(); }  ///deprecated: use getRelBins instead


    /// output functions

    String logHistoStats(bool absBins = true) const;   /// for xml output

    String printHistoStats(bool absBins = true, unsigned maxBins = 0) const; /// for log output (in more readable format)

    String printRelBins(unsigned maxBins = 0, double lowerQuantile = 0.05, double upperQuantile = 0.95) const;

    String printRelAbsBins() const;


    private:

      long long countUsed, countData;

      double count, min, max, mean, median, mode, stdDev, rms, stdDevMAD, skewness;

      QuantileVector quantiles;

      AbsBinVector bins;

      double binWidth;

      opals::String label;

      HistoMode calcMode;

      bool exactComputation;

  };

}