PMF.h

Go to the documentation of this file.

/************************************************************************
 *  Copyright (C) 2012 Eindhoven University of Technology (TU/e).       *
 *  All rights reserved.                                                *
 ************************************************************************
 *  Redistribution and use in source and binary forms, with or without  *
 *  modification, are permitted provided that the following conditions  *
 *  are met:                                                            *
 *                                                                      *
 *      1.  Redistributions of source code must retain the above        *
 *          copyright notice, this list of conditions and the following *
 *          disclaimer.                                                 *
 *                                                                      *
 *      2.  Redistributions in binary form must reproduce the above     *
 *          copyright notice, this list of conditions and the following *
 *          disclaimer in the documentation and/or other materials      *
 *          provided with the distribution.                             *
 *                                                                      *
 *  THIS SOFTWARE IS PROVIDED BY TU/e "AS IS" AND ANY EXPRESS OR        *
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED      *
 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE  *
 *  ARE DISCLAIMED. IN NO EVENT SHALL TU/e OR CONTRIBUTORS BE LIABLE    *
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        *
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT   *
 *  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;     *
 *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF       *
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           *
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE   *
 *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH    *
 *  DAMAGE.                                                             *
 *                                                                      *
 *  The views and conclusions contained in the software and             *
 *  documentation are those of the authors and should not be            *
 *  interpreted as representing official policies, either expressed or  *
 *  implied, of TU/e.                                                   *
 ************************************************************************/

#ifndef PROBLIB_PMF_H_
#define PROBLIB_PMF_H_

#include "PDF.h"

namespace pbl {

class PMF : public PDF {

public:

        PMF(int domain_size = -1);

        PMF(const PMF& pmf);

        virtual ~PMF();

        PMF& operator=(const PMF& other);

        PMF* clone() const;

        double getProbability(const std::string& value) const;

        double getProbability(const std::string& value, int domain_size) const;

        void setProbability(const std::string& value, double p);

        void setExact(const std::string& value);

        void getValues(std::vector<std::string>& values) const;

        void getProbabilities(std::vector<double>& probabilities) const;

        double getLikelihood(const PDF& pdf) const;

        double getLikelihood(const PMF& pmf) const;

        bool getExpectedValue(std::string& v) const;

        void update(const pbl::PMF& pmf);

        void setDomainSize(int domain_size);

        int getDomainSize() const;

        void normalize();

        std::string toString(const std::string& indent = "") const;

        double getDensity(const arma::vec& v) const;

        double getMaxDensity() const;

        double getProbabilityUnknown() const;

        double getProbabilityUnknown(int domain_size) const;

        // obsolete

        std::string getMostProbableValue() const;


protected:

        struct PMFStruct {

                int domain_size_;

                double total_prob_;

                std::map<std::string, double> pmf_;

                int n_ptrs_;

                PMFStruct(int domain_size) : domain_size_(domain_size), total_prob_(0), n_ptrs_(1) { }

                PMFStruct(const PMFStruct& orig) : domain_size_(orig.domain_size_), total_prob_(orig.total_prob_), pmf_(orig.pmf_), n_ptrs_(1) { }
        };

        PMFStruct* ptr_;

        void cloneStruct();

};

}

#endif /* PMF_H_ */