root/applications/robust/robustlib.h @ 1171

/*!
  \file
  \brief Robust Bayesian auto-regression model
  \author Jan Sindelar.
*/

#ifndef ROBUST_H
#define ROBUST_H

#include <stat/exp_family.h>
#include <limits>
        
using namespace bdm;
using namespace std;

#include <vector>

public const max_range = numeric_limits<double>::max( )/10e-5.0;

class polyhedron;
class vertex;

class polyhedron
{
        vector<&polyhedron> parents;

        vector<&polyhedron> children;

        vector<&vertex> vertices;

        vector<&polyhedron> positivechildren;

        vector<&polyhedron> negativechildren;

        vector<&polyhedron> neutralchildren;

        vector<vector<&vertex>> triangulations;

        int multiplicity = 1;   

public:

        vector<int> kids_rel_addresses;

        polyhedron()
        {
                parents  = new vector<&polyhedron>();
                children = new vector<&polyhedron>();
                vertices = new vector<&vertex>();
                
                positivechildren = new vector(&polyhedron)();
                negativechildren = new vector(&polyhedron)();
                neutralchildren  = new vector(&polyhedron)();

                triangulations = new vector<vector<&vertex>>();

                kids_rel_addresses = new vector<int>();
        
        }
        

        void RaiseMultiplicity()
        {
                multiplicity++;
        }

        void LowerMultiplicity()
        {
                multiplicity--;
        }
        
        
};

class vertex : polyhedron
{
        vector<double> coordinates;

public:

        vertex();

        vertex(vector<double> coordinates)
        {
                this.coordinates = coordinates;
        }

        void push_coordinate(double coordinate)
        {
                coordinates.push_back(coordinate);
        }

        vector<double> get_coordinates()
        {
                return this.coordinates();
        }
}

class toprow : polyhedron
{
        vector<double> condition;

public:

        toprow();

        toprow(double condition)
        {
                this.condition = condition;
        }

}




//! Conditional(e) Multicriteria-Laplace-Inverse-Gamma distribution density
class emlig : public eEF{

        vector<vector<&polyhedron>> statistic;
        
public: 

        emlig(int number_of_parameters)
        {
                create_statistic(int number_of_parameters);
        }

        emlig(vector<vector<&polyhedron>> statistic)
        {
                this.statistic = statistic;
        }



protected:

        create_statistic(int number_of parameters)
        {
                vector<double> origin_coord = new vector<double>();     

                origin = new vertex(origin_coord);

                origin.vertices.push_back(origin);

                vector<&polyhedron> origin_vec = new vector(&polyhedron)(1,);

                statistic.push_back(origin_vec);

                for(int i=0;i++;i<number_of_parameters)
                {
                        vertex new_point1 = new vertex(origin.get_coordinates().push_back(max_range));
                        vertex new_point2 = new vertex(origin.get_coordinates().push_back(-max_range)); 

                        vector(vector(&polyhedron)) new_statistic1 = new vector(vector(&polyhedron));
                        vector(vector(&polyhedron)) new_statistic2 = new vector(vector(&polyhedron));

                        
                        for(int j=0;j++;j<statistic.size())
                        {
                                vector<&polyhedron>::iterator horiz_ref = statistic[j].begin();

                                int element_number = 0;

                                do
                                {       
                                        if(!horiz_ref.parents.empty())
                                        {
                                                vector<&polyhedron>::iterator end_ref = horiz_ref.parents.end();

                                                vector<&polyhedron>::iterator parent_ref = horiz_ref.parents.begin();

                                                do
                                                {
                                                        parent_ref.kids_rel_addresses.push_back(element_number);

                                                        parent_ref++;
                                                }
                                                while(parent_ref!=end_ref)
                                        }

                                        toprow current_copy1 = new toprow(new vector<int>(i+2,0));
                                        toprow current_copy2 = new toprow(new vector<int>(i+2,0));

                                        vector<&vertex>::iterator vert_ref = horiz_ref.vertices.begin();

                                        do
                                        {
                                                current_copy1.vertices.push_back(vert_ref);
                                                current_copy2.vertices.push_back(vert_ref);

                                                vert_ref++;
                                        }
                                        while(!vert_ref!=horiz_ref.vertices.end())

                                        current_copy1.vertices.push_back(new_point1);
                                        current_copy2.vertices.push_back(new_point2);

                                        current_copy1.triangulations.push_back(current_copy1.vertices);
                                        current_copy2.triangulations.push_back(current_copy2.vertices);

                                        vector<int>::iterator kid_ref = horiz_ref.kids_rel_addresses.begin();

                                        if(!horiz_ref.kids_rel_addresses.empty())
                                        {
                                                do
                                                {                                               
                                                        current_copy1.children.push_back(new_statistic1[i,kid_ref]);
                                                        current_copy2.children.push_back(new_statistic2[i,kid_ref]);

                                                        new_statistic1[i,kid_ref].parents.push_back(current_copy1);
                                                        new_statistic2[i,kid_ref].parents.push_back(current_copy2);

                                                        kid_ref++;

                                                }
                                                while(kid_ref!=horiz_ref.kids_rel_addresses.end())

                                                horiz_ref.kids_rel_addresses.clear();
                                        }
                                        else
                                        {
                                                current_copy1.children.push_back(new_point1);
                                                current_copy2.childern.push_back(new_point2);

                                                new_point1.parents.push_back(current_copy1);
                                                new_point2.parents.push_back(current_copy2);
                                        }

                                        current_copy1.children.push_back(horiz_ref);
                                        current_copy2.children.push_back(horiz_ref);

                                        new_statistic1[i+1].push_back(current_copy1);
                                        new_statistic2[i+1].push_back(current_copy2);
                                        
                                        element_number++;
                                }
                                while(statistic[j].end() != horiz_ptr++)
                        }                               
                        
                }
        }


        
        
};

//! Robust Bayesian AR model for Multicriteria-Laplace-Inverse-Gamma density
class RARX : public BMEF{
};


#endif //TRAGE_H