LArDiscreteProbabilityVector.h

Go to the documentation of this file.

#ifndef LAR_DISCRETE_PROBABILITY_VECTOR_H
#define LAR_DISCRETE_PROBABILITY_VECTOR_H 1

#include "Pandora/PandoraInternal.h"
#include "Pandora/StatusCodes.h"

#include <limits>
#include <random>
#include <utility>
#include <vector>

namespace lar_content
{

class DiscreteProbabilityVector
{
public:
    template <typename TX, typename TY>
    using InputDatum = std::pair<TX, TY>;

    template <typename TX, typename TY>
    using InputData = std::vector<InputDatum<TX, TY>>;

    typedef InputData<float, float> AllFloatInputData;

    typedef pandora::FloatVector ResamplingPoints;

    template <typename TX, typename TY>
    DiscreteProbabilityVector(const InputData<TX, TY> &inputData, const TX xUpperBound, const bool useWidths);

    DiscreteProbabilityVector(const DiscreteProbabilityVector &discreteProbabilityVector, const ResamplingPoints &resamplingPoints);

    DiscreteProbabilityVector(const DiscreteProbabilityVector &discreteProbabilityVector, std::mt19937 &randomNumberGenerator);

    float EvaluateCumulativeProbability(const float x) const;

    unsigned int GetSize() const;

    float GetX(const unsigned int index) const;

    float GetProbability(const unsigned int index) const;

    float GetProbabilityDensity(const unsigned int index) const;

    float GetCumulativeProbability(const unsigned int index) const;

    float GetWidth(const unsigned int index) const;

    void GetAllAtIndex(const unsigned int index, float &x, float &probabilityDensity, float &cumulativeProbability, float &width) const;

private:
    class DiscreteProbabilityDatum
    {
    public:
        DiscreteProbabilityDatum(const float x, const float densityDatum, const float cumulativeDatum, const float width);

        float GetX() const;

        float GetDensityDatum() const;

        float GetCumulativeDatum() const;

        float GetWidth() const;

    private:
        float m_x;               
        float m_densityDatum;    
        float m_cumulativeDatum; 
        float m_width;           
    };

    typedef std::vector<DiscreteProbabilityDatum> DiscreteProbabilityData;

    template <typename TX, typename TY>
    DiscreteProbabilityData InitialiseDiscreteProbabilityData(InputData<TX, TY> inputData) const;

    DiscreteProbabilityData ResampleDiscreteProbabilityData(
        const DiscreteProbabilityVector &discreteProbabilityVector, const ResamplingPoints &resamplingPoints) const;

    DiscreteProbabilityData RandomiseDiscreteProbabilityData(
        const DiscreteProbabilityVector &discreteProbabilityVector, std::mt19937 &randomNumberGenerator) const;

    template <typename TX, typename TY>
    static bool SortInputDataByX(const InputDatum<TX, TY> &lhs, const InputDatum<TX, TY> &rhs);

    template <typename TX, typename TY>
    float CalculateNormalisation(const InputData<TX, TY> &inputData) const;

    void VerifyCompleteData() const;

    void VerifyElementRequest(const unsigned int index) const;

    float m_xUpperBound;                               
    bool m_useWidths;                                  
    DiscreteProbabilityData m_discreteProbabilityData; 
};

//------------------------------------------------------------------------------------------------------------------------------------------

inline unsigned int DiscreteProbabilityVector::GetSize() const
{
    return m_discreteProbabilityData.size();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::GetX(const unsigned int index) const
{
    this->VerifyElementRequest(index);

    return m_discreteProbabilityData.at(index).GetX();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::GetProbability(const unsigned int index) const
{
    this->VerifyElementRequest(index);

    return m_discreteProbabilityData.at(index).GetDensityDatum() * (m_useWidths ? m_discreteProbabilityData.at(index).GetWidth() : 1.f);
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::GetProbabilityDensity(const unsigned int index) const
{
    this->VerifyElementRequest(index);

    return m_discreteProbabilityData.at(index).GetDensityDatum();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::GetCumulativeProbability(const unsigned int index) const
{
    this->VerifyElementRequest(index);

    return m_discreteProbabilityData.at(index).GetCumulativeDatum();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::GetWidth(const unsigned int index) const
{
    this->VerifyElementRequest(index);

    return m_discreteProbabilityData.at(index).GetWidth();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline void DiscreteProbabilityVector::GetAllAtIndex(
    const unsigned int index, float &x, float &probabilityDensity, float &cumulativeProbability, float &width) const
{
    this->VerifyElementRequest(index);

    const DiscreteProbabilityDatum &theDatum(m_discreteProbabilityData.at(index));
    x = theDatum.GetX();
    probabilityDensity = theDatum.GetDensityDatum();
    cumulativeProbability = theDatum.GetCumulativeDatum();
    width = theDatum.GetWidth();
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline DiscreteProbabilityVector::DiscreteProbabilityDatum::DiscreteProbabilityDatum(
    const float x, const float densityDatum, const float cumulativeDatum, const float width) :
    m_x(x),
    m_densityDatum(densityDatum),
    m_cumulativeDatum(cumulativeDatum),
    m_width(width)
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::DiscreteProbabilityDatum::GetX() const
{
    return m_x;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::DiscreteProbabilityDatum::GetDensityDatum() const
{
    return m_densityDatum;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::DiscreteProbabilityDatum::GetCumulativeDatum() const
{
    return m_cumulativeDatum;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline float DiscreteProbabilityVector::DiscreteProbabilityDatum::GetWidth() const
{
    return m_width;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline void DiscreteProbabilityVector::VerifyCompleteData() const
{
    if (2 > m_discreteProbabilityData.size())
        throw pandora::StatusCodeException(pandora::STATUS_CODE_NOT_INITIALIZED);

    if (m_discreteProbabilityData.back().GetX() - m_xUpperBound > std::numeric_limits<float>::epsilon())
        throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);

    return;
}

//------------------------------------------------------------------------------------------------------------------------------------------

inline void DiscreteProbabilityVector::VerifyElementRequest(const unsigned int index) const
{
    if (this->GetSize() < index)
        throw pandora::StatusCodeException(pandora::STATUS_CODE_OUT_OF_RANGE);

    return;
}

} // namespace lar_content

#endif // #ifndef  LAR_DISCRETE_PROBABILITY_VECTOR_H