Distribution.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : Distribution
 * 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 DistributionH
#define DistributionH

#include <zeusmath/Stochastic/Interfaces/IDistribution.hpp>
#include <zeusmath/System/Constants.h>
#include <zeusbase/System/ArrayList.hpp>
#include <zeusbase/System/Pair.hpp>
#include <math.h>


BEGIN_NAMESPACE_Zeus

typedef TPair<Float, Float>  TMappedValue;

/***************************************************************************/
/***************************************************************************/
zeusmath_class TDistribution : public IDistribution
{
  public:
    TDistribution(const TArrayList<Float>& rlstData, bool bDataAsProbabilities);
    TDistribution(const Float* pafData, Int iArraySize, bool bDataAsProbabilities);
    TDistribution(const Float* pafSampleData, const Float* pafProb, Int iArraySize);
    TDistribution(const TArrayList<TMappedValue>& rlstData);
    TDistribution(const TDistribution& rDist);

    virtual ~TDistribution();

    //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;

    //sample based methods
    const TMappedValue& getSampleConst(Int iIndex) const;
    TMappedValue& getSample(Int iIndex);
    Int getSampleCount() const;
    Float getSampleValue(Int iIndex) const;
    Float getProbabilitySum() const;
    Float getMaximumSampleValue() const;
    Float getMinimumSampleValue() const;

    //static methods to operate on arrays
    static Float getMean(const TArrayList<Float>& rlstData);
    static Float getMean(const Float* pafData, Int iCount);

    static Float getMedian(const TArrayList<Float>& rlstData);
    static Float getMedian(const Float* pafData, Int iCount);
    static Float getMedian(const Float* pafData, Int iCount, Float fTotalArea);

    static Float getStdDeviation(const TArrayList<Float>& rlstData);
    static Float getStdDeviation(const Float* pafData, Int iCount);

  protected:

  private:
    TArrayList<TMappedValue> m_lstData;

    void create(const Float* pafSampleData, const Float* pafProb, Int iArraySize);
};

//INLINE METHODS
/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TDistribution::getStdDeviation() const
{
  return TMath::sqrt(getVariance());
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TDistribution::getProb(const Float& /*rfX*/) const
{
  return 0.0; //not defined
}

/****************************************************************************/
/****************************************************************************/
inline Float MQUALIFIER TDistribution::getSampleProb(Int iSample) const
{
  return getSampleConst(iSample).getSecondConst();
}

/****************************************************************************/
/****************************************************************************/
inline const TMappedValue& TDistribution::getSampleConst(Int iIndex) const
{
  return m_lstData.getItemConst(iIndex);
}

/****************************************************************************/
/****************************************************************************/
inline TMappedValue& TDistribution::getSample(Int iIndex)
{
  return m_lstData.getItem(iIndex);
}

/****************************************************************************/
/****************************************************************************/
inline Int TDistribution::getSampleCount() const
{
  return m_lstData.getCount();
}

/****************************************************************************/
/****************************************************************************/
inline Float TDistribution::getSampleValue(Int iIndex) const
{
  return getSampleConst(iIndex).getFirstConst();
}

/****************************************************************************/
/****************************************************************************/
inline Float TDistribution::getProbabilitySum() const
{
  return getCumulativeProb(0, m_lstData.getCount()-1);
}

/****************************************************************************/
/****************************************************************************/
inline /*static*/ Float TDistribution::getMean(const TArrayList<Float>& rlstData)
{
  return TDistribution::getMean(rlstData.getArrayConst(), rlstData.getCount());
}

/****************************************************************************/
/****************************************************************************/
inline /*static*/ Float TDistribution::getMedian(const TArrayList<Float>& rlstData)
{
  return TDistribution::getMedian(rlstData.getArrayConst(), rlstData.getCount());
}

/****************************************************************************/
/****************************************************************************/
inline /*static*/ Float TDistribution::getMedian(const Float* pafData, Int iCount)
{
  Float fTotal = 1.0;

  for (Int i = 0; i < iCount; i++)
  {
    fTotal += pafData[i];
  }
  return TDistribution::getMedian(pafData, iCount, fTotal);
}

/****************************************************************************/
/****************************************************************************/
inline /*static*/ Float TDistribution::getStdDeviation(const TArrayList<Float>& rlstData)
{
  return TDistribution::getStdDeviation(rlstData.getArrayConst(), rlstData.getCount());
}


END_NAMESPACE_Zeus
//---------------------------------------------------------------------------
#endif