discreteDistribution.hpp

Go to the documentation of this file.

#ifndef DISCRETEDISTRIBUTION_HPP
#define DISCRETEDISTRIBUTION_HPP

#include <cmath>
#include <vector>
#include <fstream>
#include <algorithm>

namespace canopy
{

class discreteDistribution
{
    public:
        // Methods
        //--------

        discreteDistribution() : n_classes(0) {}

        discreteDistribution(const int num_classes)
        {
            initialise(num_classes);
        }

        void initialise(const int num_classes)
        {
            n_classes = num_classes;
            prob.resize(n_classes);
            std::fill(prob.begin(),prob.end(),0.0);
        }

        void reset()
        {
            std::fill(prob.begin(),prob.end(),0.0);
        }

        float pdf(const int x) const
        {
            return prob[x];
        }

        void normalise()
        {
            float sum = 0.0;
            for(int c = 0; c < n_classes; ++c)
                sum += prob[c];

            for(int c = 0; c < n_classes; ++c)
                prob[c] /= sum;
        }

        void printOut(std::ofstream& stream) const
        {
            for(int c = 0; c < n_classes - 1; c++)
                stream << prob[c] << " ";
            stream << prob[n_classes - 1];
        }

        void readIn(std::ifstream& stream)
        {
            for(int c = 0; c < n_classes; c++)
                stream >> prob[c];
        }

        void raiseDistributionTemperature(const double T)
        {
            if(T > 0.0)
            {
                for(int c = 0; c < n_classes; ++c)
                prob[c] = std::exp(prob[c]/T);
                normalise();
            }
        }

        // Template methods, defined below
        // --------------------------------

        // Function to fit the parameters of the distribution, given a set of labels
        template <class TLabelIterator, class TIdIterator>
        void fit(TLabelIterator first_label, TLabelIterator last_label, TIdIterator /*unused*/);

        // Get the pdf of a given id and label
        template <class TId>
        float pdf(const int x, const TId /*id*/) const;

        // Aggregates the influence of the dist into the model, but does not necessarily normalise
        template <class TId>
        void combineWith(const discreteDistribution& dist, const TId /*id*/);

        friend std::ofstream& operator<< (std::ofstream& stream, const discreteDistribution& dist) { dist.printOut(stream); return stream;}

        friend std::ifstream& operator>> (std::ifstream& stream, discreteDistribution& dist) { dist.readIn(stream); return stream;}

    protected:
        // Data
        int n_classes; 
        std::vector<float> prob; 

};



template <class TLabelIterator, class TIdIterator>
void discreteDistribution::fit(TLabelIterator first_label, const TLabelIterator last_label, TIdIterator /*unused*/)
{
    const int n_data = std::distance(first_label, last_label);

    if(n_data == 0)
    {
        std::fill(prob.begin(),prob.end(),1.0/float(n_classes));
    }
    else
    {
        std::fill(prob.begin(),prob.end(),0.0);

        for( ; first_label != last_label; ++first_label)
            prob[*first_label] += 1.0;

        std::for_each(prob.begin(),prob.end(), [=] (float& p) { p /= float(n_data); });
    }
}

template<class TId>
float discreteDistribution::pdf(const int x, const TId /*id*/) const
{
    return prob[x];
}

template <class TId>
void discreteDistribution::combineWith(const discreteDistribution& dist, const TId /*id*/)
{
    for(int c = 0; c < n_classes; c++)
        prob[c] += dist.prob[c];
}

}// end of namespace

#endif
// DISCRETEDISTRIBUTION_HPP