histogram2d.h

Go to the documentation of this file.

/*

  This file is a part of MeanWalker, a library which provides utilities to
  sample from probability distributions using methods like the 
  Metropilis-Hastings algorithm and Goodman-Weare algorithm.

  Copyright (C) 2012 Jori Liesenborgs

  Contact: jori.liesenborgs@gmail.com
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  
*/

#ifndef MEANWALKER_HISTOGRAM2D_H

#define MEANWALKER_HISTOGRAM2D_H

#include "meanwalkerconfig.h"
#include <errut/errorbase.h>
#include <stdint.h>
#include <iostream>
#include <vector>
#include <list>

namespace meanwalker
{

class MEANWALKER_IMPORTEXPORT Histogram2D : public errut::ErrorBase
{
public:
        Histogram2D();
        ~Histogram2D();

        bool init(double minValueX, double maxValueX, size_t numBinsX,
                  double minValueY, double maxValueY, size_t numBinsY);

        void clear();

        void destroy();

        void process(double x, double y);

        double getMinValueX() const                                                                     { return m_minValueX; }

        double getMaxValueX() const                                                                     { return m_maxValueX; }

        size_t getNumberOfBinsX() const                                                                 { return m_numX; }

        double getMinValueY() const                                                                     { return m_minValueY; }

        double getMaxValueY() const                                                                     { return m_maxValueY; }

        size_t getNumberOfBinsY() const                                                                 { return m_numY; }

        size_t getBinCount(size_t bin1, size_t bin2) const                                              { return m_histogram[bin1 + bin2*m_numX]; }

        double getProbabilityDensity(size_t bin1, size_t bin2) const                                    { return ((double)m_histogram[bin1 + bin2*m_numX]/(double)m_totalCount)/m_binArea; }

        double getInsideProbabilityDensity(size_t bin1, size_t bin2) const                              { return ((double)m_histogram[bin1 + bin2*m_numX]/(double)(m_totalCount-m_outsideCount))/m_binArea; }

        double getBinCenterX(size_t bin1) const                                                         { return ((double)bin1+0.5)*m_binWidth+m_minValueX; }

        double getBinCenterY(size_t bin2) const                                                         { return ((double)bin2+0.5)*m_binHeight+m_minValueY; }

        double getBinWidth() const                                                                      { return m_binWidth; }

        double getBinHeight() const                                                                     { return m_binHeight; }

        size_t getTotalCount() const                                                                    { return m_totalCount; }

        size_t getOutsideCount() const                                                                  { return m_outsideCount; }

        size_t getInsideCount() const                                                                   { return m_totalCount - m_outsideCount; }

        void print(bool blocks = true) const;
protected:
        std::vector<size_t> m_histogram;
        double m_minValueX, m_maxValueX, m_binWidth;
        double m_minValueY, m_maxValueY, m_binHeight;
        double m_doubleBinsX, m_doubleBinsY;
        double m_binArea;
        size_t m_totalCount, m_outsideCount;
        size_t m_numX, m_numY;
};

inline void Histogram2D::process(double x, double y)
{
        double binDoubleX = (x-m_minValueX)/m_binWidth;
        double binDoubleY = (y-m_minValueY)/m_binHeight;

        if (binDoubleX < 0 || binDoubleX >= m_doubleBinsX ||
            binDoubleY < 0 || binDoubleY >= m_doubleBinsY)
                m_outsideCount++;
        else
                m_histogram[(int)binDoubleX + (int)binDoubleY * m_numX]++;

        m_totalCount++;
}

} // end namespace   

#endif // MEANWALKER_HISTOGRAM2D_H