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