Changeset 1216

Timestamp:

10/14/10 18:33:52 (14 years ago)

Author:

sindj

Message:

Splitting polyhedrons in statistic - continued. Not finished. JS

Location:

applications/robust

Files:

• main.cpp (modified) (2 diffs)
• robustlib.h (modified) (16 diffs)

applications/robust/main.cpp

@@ -8 +8 @@
 
 #include "robustlib.h"
+#include <vector>
 using namespace itpp;
 
@@ -16 +17 @@
         emlig* emlig1 = new emlig(3);
 
-        vec condition = "3.0 -5.0 3.0 2.0";     
+        emlig1->step_me();
+
+        vec condition = "3.0 -5.0 -3.0 -2.0";   
 
         emlig1->add_condition(condition);
+
+        vector<int> sizevector;
+        for(int s = 0;s<=emlig1->number_of_parameters;s++)
+        {
+                sizevector.push_back(emlig1->statistic_rowsize(s));
+        }
+
+        emlig1->step_me();
+
+        condition = "-5.0 2.3 2.3 -1.0";
+
+        emlig1->add_condition(condition);
+
+        sizevector.clear();
+        for(int s = 0;s<=emlig1->number_of_parameters;s++)
+        {
+                sizevector.push_back(emlig1->statistic_rowsize(s));
+        }
 
         return 0;

applications/robust/robustlib.h

@@ -18 +18 @@
 using namespace itpp;
 
-const double max_range = numeric_limits<double>::max()/10e-5;
+const double max_range = 99999999999999999999999.0;//numeric_limits<double>::max()/10e-10;
 
 enum actions {MERGE, SPLIT};
@@ -413 +413 @@
                 }
         }
+
 
 
@@ -557 +558 @@
                                                                 current_parent->totallyneutralchildren.clear();
                                                                 current_parent->totallyneutralgrandchildren.clear();
-                                                                current_parent->totally_neutral = NULL; 
+                                                                current_parent->totally_neutral = NULL;
+                                                                current_parent->kids_rel_addresses.clear();
+                                                                //current_parent->set_state(0, SPLIT);
                                                         }
                                                 }
@@ -573 +576 @@
         
 public: 
+
+        int number_of_parameters;
 
         /// A default constructor creates an emlig with predefined statistic representing only the range of the given
@@ -578 +583 @@
         emlig(int number_of_parameters)
         {       
-
-                create_statistic(number_of_parameters);
-
-                for(int i = 0;i<statistic.size();i++)
-                {
-                        list<polyhedron*> empty_split;
-                        list<polyhedron*> empty_merge;
-
-                        for_splitting.push_back(empty_split);
-                        for_merging.push_back(empty_merge);
-                }
+                this->number_of_parameters = number_of_parameters;
+
+                create_statistic(number_of_parameters);         
         }
 
@@ -598 +595 @@
         }
 
+        void step_me()
+        {
+                for(int i = 0;i<statistic.size();i++)
+                {
+                        for(polyhedron* horiz_ref = statistic.rows[i];horiz_ref!=statistic.get_end();horiz_ref=horiz_ref->next_poly)
+                        {
+                                char* string = "Checkpoint";
+                        }
+                }
+        }
+
+        int statistic_rowsize(int row)
+        {
+                return statistic.row_size(row);
+        }
+
         void add_condition(vec toadd)
         {
@@ -605 +618 @@
         }
 
+
         void remove_condition(vec toremove)
         {
@@ -612 +626 @@
         
         }
+
 
         void add_and_remove_condition(vec toadd, vec toremove)
@@ -617 +632 @@
                 bool should_remove = (toremove.size() != 0);
                 bool should_add    = (toadd.size() != 0);
+
+                for_splitting.clear();
+                for_merging.clear();
+
+                for(int i = 0;i<statistic.size();i++)
+                {
+                        list<polyhedron*> empty_split;
+                        list<polyhedron*> empty_merge;
+
+                        for_splitting.push_back(empty_split);
+                        for_merging.push_back(empty_merge);
+                }
 
                 list<condition*>::iterator toremove_ref = conditions.end();
@@ -754 +781 @@
                                         toprow* negative_poly = new toprow(((toprow*)current_polyhedron)->condition-toadd);
 
-                                        positive_poly->children.push_back(new_totally_neutral_child);
-                                        negative_poly->children.push_back(new_totally_neutral_child);
+                                        for(list<polyhedron*>::iterator parent_ref = current_polyhedron->parents.begin();parent_ref!=current_polyhedron->parents.end();parent_ref++)
+                                        {
+                                                (*parent_ref)->totallyneutralgrandchildren.push_back(new_totally_neutral_child);
+
+                                                (*parent_ref)->neutralchildren.remove(current_polyhedron);
+                                                (*parent_ref)->positivechildren.push_back(positive_poly);
+                                                (*parent_ref)->negativechildren.push_back(negative_poly);
+                                        }
 
                                         positive_poly->parents.insert(positive_poly->parents.end(),
@@ -765 +798 @@
                                                                                                                 current_polyhedron->parents.end());
 
+                                        positive_poly->children.push_back(new_totally_neutral_child);
+                                        negative_poly->children.push_back(new_totally_neutral_child);
+
+                                        new_totally_neutral_child->parents.push_back(positive_poly);
+                                        new_totally_neutral_child->parents.push_back(negative_poly);
+
+                                        for(list<polyhedron*>::iterator child_ref = current_polyhedron->positivechildren.begin();child_ref!=current_polyhedron->positivechildren.end();child_ref++)
+                                        {
+                                                (*child_ref)->parents.remove(current_polyhedron);
+                                                (*child_ref)->parents.push_back(positive_poly);
+                                        }                                       
+
                                         positive_poly->children.insert(positive_poly->children.end(),
                                                                                                 current_polyhedron->positivechildren.begin(),
                                                                                                                         current_polyhedron->positivechildren.end());
+
+                                        for(list<polyhedron*>::iterator child_ref = current_polyhedron->negativechildren.begin();child_ref!=current_polyhedron->negativechildren.end();child_ref++)
+                                        {
+                                                (*child_ref)->parents.remove(current_polyhedron);
+                                                (*child_ref)->parents.push_back(negative_poly);
+                                        }
 
                                         negative_poly->children.insert(negative_poly->children.end(),
@@ -778 +829 @@
                                         statistic.insert_polyhedron(k, negative_poly, current_polyhedron);                                      
 
-                                        statistic.delete_polyhedron(k, current_polyhedron);                             
+                                        statistic.delete_polyhedron(k, current_polyhedron);
+
+                                        delete current_polyhedron;
                                 }
 
@@ -785 +838 @@
                 }
 
+                /*
                 vector<int> sizevector;
                 for(int s = 0;s<statistic.size();s++)
                 {
                         sizevector.push_back(statistic.row_size(s));
-                }
+                }*/
         }
 
@@ -833 +887 @@
 
                         // And we incorporate the nonzero coordinates into the new cooordinate vectors
-                        vec origin_coord1 = concat(origin_coord,max_range);
-                        vec origin_coord2 = concat(origin_coord,-max_range);
+                        vec origin_coord1 = concat(origin_coord,-max_range); 
+                        vec origin_coord2 = concat(origin_coord,max_range);                              
+                                        
 
                         // Now we create the points
                         vertex *new_point1 = new vertex(origin_coord1);
                         vertex *new_point2 = new vertex(origin_coord2);
+
+                        new_point1->vertices.push_back(new_point1);
+                        new_point2->vertices.push_back(new_point2);
                         
                         //*********************************************************************************************************
@@ -1058 +1116 @@
                 }*/
 
-                
+                /*
                 vector<int> sizevector;
                 for(int s = 0;s<statistic.size();s++)
@@ -1064 +1122 @@
                         sizevector.push_back(statistic.row_size(s));
                 }
+                */
                 
         }