PoissonDistribution.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : PoissonDistribution
 * Package    : Zeus.ZeusMath.Stochastic
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef PoissonDistributionH
#define PoissonDistributionH

#include <zeusmath/Stochastic/Interfaces/IDistribution.hpp>
#include <zeusmath/System/Constants.h>
#include <zeusbase/System/Float.h>

BEGIN_NAMESPACE_Zeus

/***************************************************************************/
/***************************************************************************/
zeusmath_class TPoissonDistribution : public IDistribution
{
  public:
    /***********************************************************************/
    /***********************************************************************/
    inline TPoissonDistribution(const Float& rfLambda)
    {
      m_fLambda = rfLambda;
    }

    /***********************************************************************/
    /***********************************************************************/
    virtual inline ~TPoissonDistribution() {}

    static Float getProbability(const Float& rfLambda, const Float& rfX);

    //methods of IDistribution
    virtual Float MQUALIFIER getEntropy() const;
    virtual Float MQUALIFIER getExpectedValue() const;
    virtual Float MQUALIFIER getMean() const;
    virtual Float MQUALIFIER getMedian() const;
    virtual Float MQUALIFIER getVariance() const;
    virtual Float MQUALIFIER getMode() const;
    virtual Float MQUALIFIER getSkewness() const;
    virtual Float MQUALIFIER getCumulativeProb(const Float& rfStart, const Float& rfEnd) const;
    virtual Float MQUALIFIER getStdDeviation() const;
    virtual Float MQUALIFIER getProb(const Float& rfX) const;
    virtual Float MQUALIFIER getSampleProb(Int iSample) const;

  private:
    Float m_fLambda;

    static Float getCumulativeProb_internal(const Float& rfLambda, const Float& rfEnd);
};

//INLINE METHODS
/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getEntropy() const
{
  return 0.5 * TMath::ln(TConstants::Pi * TMath::exp(1)*m_fLambda) - 1.0/(12*m_fLambda) -
         1.0/(241*m_fLambda*m_fLambda) - 19.0/(360*m_fLambda*m_fLambda*m_fLambda);
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getExpectedValue() const
{
  return m_fLambda;
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getMean() const
{
  return m_fLambda;
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getMedian() const
{
  //formula taken from wikipedia
  return TMath::floor(m_fLambda + 1.0/3.0 - 0.02/m_fLambda);
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getVariance() const
{
  return m_fLambda;
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getStdDeviation() const
{
  return TMath::sqrt(m_fLambda);
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getMode() const
{
  Float fRetval = TMath::floor(m_fLambda);

  //if lambda is an interger
  if (TFloat::equalsFloat(m_fLambda, fRetval))
  {
    fRetval = m_fLambda - 1;
  }
  return fRetval;
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getSkewness() const
{
  return TMath::pow(m_fLambda, -0.5);
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getProb(const Float& rfX) const
{
  return TPoissonDistribution::getProbability(m_fLambda, rfX);
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TPoissonDistribution::getSampleProb(Int iSample) const
{
  return TPoissonDistribution::getProbability(m_fLambda, iSample);
}


/****************************************************************************/
/****************************************************************************/
inline /*static*/ Float TPoissonDistribution::getProbability(const Float& rfLambda, const Float& rfX)
{
  return TMath::pow(rfLambda, rfX) / TFloat::getFactorial(rfX) * TMath::exp(-rfLambda);
}


END_NAMESPACE_Zeus

#endif