Changeset 1213 for applications/robust

Timestamp:

10/08/10 18:39:39 (14 years ago)

Author:

sindj

Message:

Predelani vektoru na listy a doplneni drobnosti - nedokonceno. JS

Location:

applications/robust

Files:

• main.cpp (modified) (1 diff)
• robustlib.h (modified) (25 diffs)

applications/robust/main.cpp

@@ -10 +10 @@
 using namespace itpp;
 
-//using namespace bdm;
+using namespace bdm;
 
 int main ( int argc, char* argv[] ) {

applications/robust/robustlib.h

@@ -11 +11 @@
 #include <limits>
 #include <vector>
+#include <list>
 #include <algorithm>
         
@@ -41 +42 @@
 public:
         /// A list of polyhedrons parents within the Hasse diagram.
-        vector<polyhedron*> parents;
+        list<polyhedron*> parents;
 
         /// A list of polyhedrons children withing the Hasse diagram.
-        vector<polyhedron*> children;
+        list<polyhedron*> children;
 
         /// All the vertices of the given polyhedron
-        vector<vertex*> vertices;
+        list<vertex*> vertices;
 
         /// A list used for storing children that lie in the positive region related to a certain condition
-        vector<polyhedron*> positivechildren;
+        list<polyhedron*> positivechildren;
 
         /// A list used for storing children that lie in the negative region related to a certain condition
-        vector<polyhedron*> negativechildren;
+        list<polyhedron*> negativechildren;
 
         /// Children intersecting the condition
-        vector<polyhedron*> neutralchildren;
-
-        vector<polyhedron*> totallyneutralgrandchildren;
-
-        vector<polyhedron*> totallyneutralchildren;
+        list<polyhedron*> neutralchildren;
+
+        list<polyhedron*> totallyneutralgrandchildren;
+
+        list<polyhedron*> totallyneutralchildren;
 
         bool totally_neutral;
 
-        vector<polyhedron*> mergechildren;
+        list<polyhedron*> mergechildren;
 
         polyhedron* positiveparent;
@@ -73 +74 @@
 
         /// List of triangulation polyhedrons of the polyhedron given by their relative vertices. 
-        vector<vector<vertex*>> triangulations;
+        list<list<vertex*>> triangulations;
 
         /// A list of relative addresses serving for Hasse diagram construction.
-        vector<int> kids_rel_addresses;
+        list<int> kids_rel_addresses;
 
         /// Default constructor
@@ -197 +198 @@
 
         /// Default constructor
-        toprow();
+        toprow(){};
 
         /// Constructor creating a toprow from the condition
@@ -228 +229 @@
         /// A statistic in a form of a Hasse diagram representing a complex of convex polyhedrons obtained as a result
         /// of data update from Bayesian estimation or set by the user if this emlig is a prior density
-        vector<vector<polyhedron*>> statistic;
-
-        vector<vector<polyhedron*>> for_splitting;
+        vector<list<polyhedron*>> statistic;
+
+        vector<list<polyhedron*>> for_splitting;
                 
-        vector<vector<polyhedron*>> for_merging;
-
-        vector<condition*> conditions;
+        vector<list<polyhedron*>> for_merging;
+
+        list<condition*> conditions;
 
         double normalization_factor;
@@ -240 +241 @@
         void alter_toprow_conditions(vec condition, bool should_be_added)
         {
-                for(vector<polyhedron*>::iterator horiz_ref = statistic[statistic.size()-1].begin();horiz_ref<statistic[statistic.size()-1].end();horiz_ref++)
+                for(list<polyhedron*>::iterator horiz_ref = (statistic.end()--)->begin();horiz_ref!=(statistic.end()--)->end();horiz_ref++)
                 {
                         double product = 0;
 
-                        vector<vertex*>::iterator vertex_ref = (*horiz_ref)->vertices.begin();
+                        list<vertex*>::iterator vertex_ref = (*horiz_ref)->vertices.begin();
 
                         do
@@ -267 +268 @@
         {                       
 
-                bool should_remove = (toremove.size() != 0);
-                bool should_add    = (toadd.size() != 0);
+                bool shouldmerge = (toremove.size() != 0);
+                bool shouldsplit    = (toadd.size() != 0);
                 
                 if(shouldsplit||shouldmerge)
                 {
-                        for(vector<polyhedron*>::iterator parent_iterator = sender->parents.begin();parent_iterator<sender->parents.end();parent_iterator++)
+                        for(list<polyhedron*>::iterator parent_iterator = sender->parents.begin();parent_iterator!=sender->parents.end();parent_iterator++)
                         {
                                 polyhedron* current_parent = *parent_iterator;
@@ -313 +314 @@
                                                 if(parent_state > 0)
                                                 {
-                                                        for(vector<polyhedron*>::iterator merge_child = current_parent->mergechildren.begin(); merge_child < current_parent->mergechildren.end();merge_child++)
+                                                        for(list<polyhedron*>::iterator merge_child = current_parent->mergechildren.begin(); merge_child != current_parent->mergechildren.end();merge_child++)
                                                         {
                                                                 (*merge_child)->positiveparent = current_parent;
@@ -321 +322 @@
                                                 if(parent_state < 0)
                                                 {
-                                                        for(vector<polyhedron*>::iterator merge_child = current_parent->mergechildren.begin(); merge_child < current_parent->mergechildren.end();merge_child++)
+                                                        for(list<polyhedron*>::iterator merge_child = current_parent->mergechildren.begin(); merge_child != current_parent->mergechildren.end();merge_child++)
                                                         {
                                                                 (*merge_child)->negativeparent = current_parent;
@@ -413 +414 @@
                                         if(is_last)
                                         {
-                                                send_state_message(current_parent,shouldsplit,shouldmerge,level+1);
+                                                send_state_message(current_parent,toadd,toremove,level+1);
                                         }
                         
@@ -429 +430 @@
                 create_statistic(number_of_parameters);
 
-                for(vector<vector<polyhedron*>::iterator local_iter = statistic.begin();local_iter<statistic.end();local_iter++)
-                {
-                        vector<polyhedron*> empty_split;
-                        vector<polyhedron*> empty_merge;
+                for(vector<list<polyhedron*>>::iterator local_iter = statistic.begin();local_iter<statistic.end();local_iter++)
+                {
+                        list<polyhedron*> empty_split;
+                        list<polyhedron*> empty_merge;
 
                         for_splitting.push_back(empty_split);
@@ -441 +442 @@
         /// A constructor for creating an emlig when the user wants to create the statistic by himself. The creation of a
         /// statistic is needed outside the constructor. Used for a user defined prior distribution on the parameters.
-        emlig(vector<vector<polyhedron*>> statistic)
+        emlig(vector<list<polyhedron*>> statistic)
         {
                 this->statistic = statistic;
@@ -466 +467 @@
                 bool should_add    = (toadd.size() != 0);
 
-                vector<condition*>::iterator toremove_ref = conditions.end();
+                list<condition*>::iterator toremove_ref = conditions.end();
                 bool condition_should_be_added = false;
 
-                for(vector<condition*>::iterator ref = conditions.begin();ref<conditions.end();ref++)
+                for(list<condition*>::iterator ref = conditions.begin();ref!=conditions.end();ref++)
                 {
                         if(should_remove)
@@ -519 +520 @@
                 
 
-                for(vector<polyhedron*>::iterator horizontal_position = statistic[0].begin();horizontal_position<statistic[0].end();horizontal_position++)
+                for(list<polyhedron*>::iterator horizontal_position = statistic.begin()->begin();horizontal_position!=statistic.begin()->end();horizontal_position++)
                 {               
                         vertex* current_vertex = (vertex*)(*horizontal_position);
@@ -538 +539 @@
                                                 current_vertex->totally_neutral = true;
 
-                                                current_vertex->multiplicity++;
+                                                current_vertex->raise_multiplicity();
                                         }                                       
                                 }
@@ -560 +561 @@
                 if(should_add)
                 {
-                        for(vector<vector<polyhedron*>>::iterator vert_ref = for_splitting.begin();vert_ref<for_splitting.end();vert_ref++)
-                        {
-                                int original_size = (*vert_ref).size();
-
-                                for(int split_counter = 0;split_counter<original_size;split_counter++)
+                        for(vector<list<polyhedron*>>::iterator vert_ref = for_splitting.begin();vert_ref<for_splitting.end();vert_ref++)
+                        {                       
+
+                                for(list<polyhedron*>::reverse_iterator split_ref = vert_ref->rbegin();split_ref != vert_ref->rend();split_ref++)
                                 {
-                                        polyhedron* current_polyhedron = (*vert_ref)[original_size-1-split_counter];
-
                                         polyhedron* new_totally_neutral_child;
+
+                                        polyhedron* current_polyhedron = (*split_ref);
                                         
                                         if(vert_ref == for_splitting.begin())
                                         {
-                                                vec coordinates1 = ((vertex*)current_polyhedron->children[0])->get_coordinates();                                               
-                                                vec coordinates2 = ((vertex*)current_polyhedron->children[1])->get_coordinates();
+                                                vec coordinates1 = ((vertex*)(*(current_polyhedron->children.begin())))->get_coordinates();                                             
+                                                vec coordinates2 = ((vertex*)(*(current_polyhedron->children.begin()++)))->get_coordinates();
                                                 coordinates2.ins(0,-1.0);
                                                 
@@ -646 +646 @@
                 // As a statistic, we have to create a vector of vectors of polyhedron pointers. It will then represent the Hasse
                 // diagram. First we create a vector of polyhedrons..
-                vector<polyhedron*> origin_vec;
+                list<polyhedron*> origin_vec;
 
                 // ..we fill it with the origin..
@@ -684 +684 @@
                         vector<vector<polyhedron*>> new_statistic2;
 
-                        // Copy the statistic by rows
+                        
+                        // Copy the statistic by rows                   
                         for(int j=0;j<statistic.size();j++)
                         {
+                                
+
                                 // an element counter
                                 int element_number = 0;
@@ -697 +700 @@
 
                                 // for each polyhedron in the given row
-                                for(vector<polyhedron*>::iterator horiz_ref = statistic[j].begin();horiz_ref<statistic[j].end();horiz_ref++)
+                                for(list<polyhedron*>::iterator horiz_ref = (statistic.begin()+j)->begin();horiz_ref!=(statistic.begin()+j)->end();horiz_ref++)
                                 {       
                                         // Append an extra zero coordinate to each of the vertices for the new dimension
-                                        // If j==0 => we loop through vertices
+                                        // If vert_ref is at the first index => we loop through vertices
                                         if(j == 0)
                                         {
@@ -706 +709 @@
                                                 ((vertex*) (*horiz_ref))->push_coordinate(0);
                                         }
+                                        /*
+                                        else
+                                        {
+                                                ((toprow*) (*horiz_ref))->condition.ins(0,0);
+                                        }*/
 
                                         // if it has parents
@@ -713 +721 @@
                                                 // This information will later be used for copying the whole Hasse diagram with each of the
                                                 // relations contained within.
-                                                for(vector<polyhedron*>::iterator parent_ref = (*horiz_ref)->parents.begin();parent_ref < (*horiz_ref)->parents.end();parent_ref++)
+                                                for(list<polyhedron*>::iterator parent_ref = (*horiz_ref)->parents.begin();parent_ref != (*horiz_ref)->parents.end();parent_ref++)
                                                 {
                                                         (*parent_ref)->kids_rel_addresses.push_back(element_number);                                                    
@@ -728 +736 @@
                                         // this condition will be a vector of zeros. There are two vectors, because we need two copies of 
                                         // the original Hasse diagram.
-                                        vec vec1(i+2);
+                                        vec vec1(number_of_parameters+1);
                                         vec1.zeros();
 
-                                        vec vec2(i+2);
+                                        vec vec2(number_of_parameters+1);
                                         vec2.zeros();
 
                                         // We create a new toprow with the previously specified condition.
-                                        toprow *current_copy1 = new toprow(vec1);
-                                        toprow *current_copy2 = new toprow(vec2);                                       
+                                        toprow* current_copy1 = new toprow(vec1);
+                                        toprow* current_copy2 = new toprow(vec2);                                       
 
                                         // The vertices of the copies will be inherited, because there will be a parent/child relation
                                         // between each polyhedron and its offspring (comming from the copy) and a parent has all the
                                         // vertices of its child plus more.
-                                        for(vector<vertex*>::iterator vert_ref = (*horiz_ref)->vertices.begin();vert_ref<(*horiz_ref)->vertices.end();vert_ref++)
-                                        {
-                                                current_copy1->vertices.push_back(*vert_ref);
-                                                current_copy2->vertices.push_back(*vert_ref);                                           
+                                        for(list<vertex*>::iterator vertex_ref = (*horiz_ref)->vertices.begin();vertex_ref!=(*horiz_ref)->vertices.end();vertex_ref++)
+                                        {
+                                                current_copy1->vertices.push_back(*vertex_ref);
+                                                current_copy2->vertices.push_back(*vertex_ref);                                         
                                         }
                                         
@@ -762 +770 @@
                                         if(!(*horiz_ref)->kids_rel_addresses.empty())
                                         {
-                                                for(vector<int>::iterator kid_ref = (*horiz_ref)->kids_rel_addresses.begin();kid_ref<(*horiz_ref)->kids_rel_addresses.end();kid_ref++)
+                                                for(list<int>::iterator kid_ref = (*horiz_ref)->kids_rel_addresses.begin();kid_ref!=(*horiz_ref)->kids_rel_addresses.end();kid_ref++)
                                                 {       
                                                         // find the child and save the relation to the parent
@@ -808 +816 @@
                                         element_number++;
                                         
-                                }                               
-                        }
-
-                        statistic[0].push_back(new_point1);
-                        statistic[0].push_back(new_point2);
+                                }
+                                
+                        }
+
+                        statistic.begin()->push_back(new_point1);
+                        statistic.begin()->push_back(new_point2);
 
                         // Merge the new statistics into the old one. This will either be the final statistic or we will
@@ -820 +829 @@
                                 if(j+1==statistic.size())
                                 {
-                                        vector<polyhedron*> support;
+                                        list<polyhedron*> support;
                                         statistic.push_back(support);
                                 }
                                 
-                                statistic[j+1].insert(statistic[j+1].end(),new_statistic1[j].begin(),new_statistic1[j].end());
-                                statistic[j+1].insert(statistic[j+1].end(),new_statistic2[j].begin(),new_statistic2[j].end());
-                        }
+                                (statistic.begin()+j+1)->insert((statistic.begin()+j+1)->end(),new_statistic1[j].begin(),new_statistic1[j].end());
+                                (statistic.begin()+j+1)->insert((statistic.begin()+j+1)->end(),new_statistic2[j].begin(),new_statistic2[j].end());
+                        }
+
+                
+                }
+
+                vector<list<toprow*>> toprow_statistic;
+                int line_count = 0;
+
+                for(vector<list<polyhedron*>>::iterator polyhedron_ref = ++statistic.begin(); polyhedron_ref!=statistic.end();polyhedron_ref++)
+                {
+                        list<toprow*> support_list;
+                        toprow_statistic.push_back(support_list);                                               
+
+                        for(list<polyhedron*>::iterator polyhedron_ref2 = polyhedron_ref->begin(); polyhedron_ref2 != polyhedron_ref->end(); polyhedron_ref2++)
+                        {
+                                toprow* support_top = (toprow*)(*polyhedron_ref2);
+
+                                toprow_statistic[line_count].push_back(support_top);
+                        }
+
+                        line_count++;
                 }
         }