randomvariable.h.svn-base

Probabilistic graphical models in matlab.

#ifndef RANDOMVARIABLE_H
#define RANDOMVARIABLE_H

#include <string>
#include <vector>
#include <list>
#include <map>
#include <numeric>

//****************** RandomVariable Declaration ********************* //

// Base class, reserved for future use. Contains an index (essential for current use), and a name (optional).

class RandomVariable
{
	
protected:
	

	const std::string name;
	const unsigned int index;
	bool conditionned;
		
public:
	
	// Constructor, destructor
		
	RandomVariable (const unsigned int);
	
	virtual ~RandomVariable ();
	
	// General functions
	
	unsigned int get_index() const;
	bool is_conditionned () const;
	
	// Virtual functions
	
	virtual void display_probabilities () const = 0;
	virtual void export_inference_to_matlab () const = 0;
	virtual void obtain_inference_from_prior_samples() = 0;
	virtual void initialize() = 0;
};

inline unsigned int RandomVariable::get_index() const
{
	return index;
}

inline bool RandomVariable::is_conditionned () const
{
	return conditionned;
}

			//****************** End of RandomVariable Declaration ********************* //

			//****************** ContinuousRandomVariable Declaration ********************* //
			
class ContinuousRandomVariable : public RandomVariable
{

public:
	
	// Constructor, destructor
	
	ContinuousRandomVariable(const unsigned int);
	
	// Inherited virtual functions
	
	void display_probabilities () const;
	void export_inference_to_matlab () const;
	void obtain_inference_from_prior_samples();
	void initialize();
	
	// Normal Functions
	
	double sample_from_particles (const std::vector <double> &, const std::vector <double> &);
	void compute_mean();
	double get_mean() const;
	double get_mean_error () const;
	void record_sample(const double);
	void set_reference_mean(const double);
	
	// Testing purposes
		
	void set_mean_bw_particles(std::vector <double> & ,  std::vector <double> &);
	
	// Debug methods
	
#ifndef NDEBUG
	
	void debug_display_state();
	
#endif
	
	// Friends
	
	friend class GaussianPotential;
	friend class BernouilliPotential;
	friend class ParticleFilterProposal;
	
private:
		
	std::vector <double> prior_samples;
	std::vector < std::pair <double, double > > distribution_approximation;
	double last_sampled_value;
	double conditionned_value;
	double mean;
	double reference_mean;
	unsigned int number_distribution_values; // this is used only for Matlab display. It has a default of 100
	bool particle_mean;
	std::vector <double> particle_means_vec;
};

inline double ContinuousRandomVariable::get_mean() const
{
	return mean;
}

inline double ContinuousRandomVariable::get_mean_error() const
{
	// This assumes the mean is already computed
	
	return ( (mean - reference_mean) * (mean - reference_mean) ) ;
}

inline void ContinuousRandomVariable::set_reference_mean(const double a)
{
	reference_mean = a;
}

//****************** End of ContinuousRandomVariable Declaration ********************* //

//****************** DiscreteRandomVariable Declaration ********************* //

// The following class could be coded with a template, so that a Discrete Random Variable could contain different types of realizations (ie, strings, for example)
// Right now it can only contain realizations of type double.

class DiscreteRandomVariable : public RandomVariable
{	
public:
		
		// Constructors, destructor
		
		DiscreteRandomVariable(const unsigned int);
		DiscreteRandomVariable(const unsigned int, const unsigned int); // constructor, setting the index AND the possible number of values
		
		virtual ~DiscreteRandomVariable();
		
		// Inherited virtual functions
		
		void display_probabilities() const;
		void export_inference_to_matlab () const;
		void obtain_inference_from_prior_samples();
		void initialize();

		// Normal functions
		
		unsigned int get_number_values() const; // good function for interface
		void observe_variable_value (const unsigned int a);
		
		void set_reference_marginals(const std::vector <double> &);
		unsigned int sample_without_recording (const std::vector <double> &);
		unsigned int sample_from_particles (const std::vector <unsigned int> &, const std::vector <double> &);
		
		// Meant to be inherited virtual later
		
		unsigned int sample(); // should be one of the only public functions accessible
		unsigned int sample_without_recording ();
		bool loop_over ();
		void set_current_probability (const double);
		void serialize_marginals (std::ofstream &) const;
		void remove_prior_samples();
		void set_equal_to_variable( RandomVariable &);
		
		double compute_error_to_reference() const;
		
		// Deprecated, should be removed as soon as possible. Still present in the particle filters and nodecombine
		
		DiscreteRandomVariable & set_value (const unsigned int);
		
		// Completely unknown, probably testing or deprecated
		// Testing purposes
		
		double get_mean();		
		void compute_mean();		
		void compute_true_mean();
		double get_mean_error();
		void set_reference_mean( double a);
		
		virtual std::vector < DiscreteRandomVariable *> uncombine();

		void set_mean_particles( std::vector <unsigned int> &);
		void set_mean_bw_particles( std::vector <unsigned int> &, std::vector <double> &);
		
		// Debug methods
		
#ifndef NDEBUG
		
		void debug_display_probabilities() const;
		
#endif
		
		// Friends (some could probably be removed)
		
		template <class RanVar, class Pot, class VertexDescriptor>
		friend class MRFMessageNode;
		
		template <class RanVar, class Pot, class VertexDescriptor>
		friend class VariableMessageNode;
		
		template <class Graph>
		friend void tree_gibbs_sampler (Graph &, const unsigned int, const unsigned int);
		
		template <class Graph>
		friend void gibbs_sampler (Graph &, const unsigned int, const unsigned int);
		
		template <class Graph>
		friend void initialize_graph_variables_random (Graph &);
		
		friend class CombinedDiscreteRandomVariable;
		
		friend class BernouilliPotential;
		
		friend class DiscretePotential;
		friend class UniqueDiscretePotential;
		friend class QMRDiscretePotential;
		friend class SingleDiscretePotential;
		friend class ChainedSingleDiscretePotential;
		
		friend class Message;
		friend class ExtractFromMessage;
		
protected:
		
		void normalize_probabilities ();
		unsigned int internal_sample();
		void set_value_at_random();
			
		bool start_loop;
		bool end_loop;

		unsigned int number_values;	// how many values the variable can take (since it is discrete)
		unsigned int last_sampled_value; // this value is very important. It represents the value used for the variable for computations involving the potentials associated with that variable. In fact it is not necessarily the last sampled value, but can be the current value in a sum, etc.

		std::vector <double> sampling_probabilities;	// these probabilities must be normalized and are used to sample
		std::vector <double> reference_marginals;
		std::vector <unsigned int> prior_samples; // this store information obtained by sampling ...
		
		// Mean part has to be investigated
		
		double reference_mean;
		double mean; // not really the mean...
		bool particle_mean;
		std::vector <double> particle_means_vec;
};

inline DiscreteRandomVariable & DiscreteRandomVariable::set_value (const unsigned int xi)
{
	if (!conditionned)
	{
		last_sampled_value = xi;
	}
	
	return *this;	
}

inline void DiscreteRandomVariable::set_equal_to_variable( RandomVariable & rv)
{
	if (!conditionned)
	{
		last_sampled_value = static_cast < DiscreteRandomVariable & > (rv).last_sampled_value;
	}
}

inline void DiscreteRandomVariable::set_current_probability (const double a)
{
	/*
	if (conditionned)
	{
		std::cout << "last sampled value : " << last_sampled_value << std::endl;
	}
	 */
	
	sampling_probabilities[last_sampled_value] = a;
}

inline unsigned int DiscreteRandomVariable::get_number_values() const
{
	return number_values;
}

inline double DiscreteRandomVariable::get_mean_error()
{
	return (mean - reference_mean ) * (mean - reference_mean );
}

inline void DiscreteRandomVariable::set_reference_mean( double a)
{
	reference_mean = a;
}

inline double DiscreteRandomVariable::get_mean()
{
	return mean;
}

//****************** End of DiscreteRandomVariable Declaration ********************* //

//****************** CombinedDiscreteRandomVariable Declaration ********************* //

class CombinedDiscreteRandomVariable : public DiscreteRandomVariable
{
	
private:
	
	std::map <unsigned int, unsigned int> correspondance_table; // maps the indexes of the combined variables to their internal indexes
	std::vector <unsigned int> number_of_variable_values; // this stores the dimension of the variables, per variable
	std::vector <unsigned int> variable_values; // this stores the actual values of the variables
	std::vector <unsigned int> help_vector;
	
	double internal_sum_over_variable(unsigned int);
	
public:
	
	CombinedDiscreteRandomVariable( std::list <DiscreteRandomVariable *>, unsigned int); // constructor, setting the index AND the possible number of values

	void set_variable_value_by_index(unsigned int, unsigned int);
	
	unsigned int get_combined_position() const;
	std::vector < DiscreteRandomVariable *> uncombine();
};

inline void CombinedDiscreteRandomVariable::set_variable_value_by_index(unsigned int a, unsigned int b)
{
	variable_values[ correspondance_table[a] ] = b;		
}

//****************** End of CombinedDiscreteRandomVariable Declaration ********************* //

#endif