Changeset 1208 for applications/robust

Timestamp:

10/03/10 15:26:26 (14 years ago)

Author:

sindj

Message:

Dodelavky mergovani a splitovani - zatim nedokonceno. JS

Location:

applications/robust

Files:

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

applications/robust/main.cpp

@@ -8 +8 @@
 
 #include "robustlib.h"
+using namespace itpp;
 
 //using namespace bdm;
@@ -13 +14 @@
 int main ( int argc, char* argv[] ) {
         
-        emlig* emlig1 = new emlig(10);
+        emlig* emlig1 = new emlig(3);
+
+        vec condition = "3.0 -5.0 3.0 2.0";     
+
+        emlig1->add_condition(condition);
 
         return 0;

applications/robust/robustlib.h

@@ -18 +18 @@
 
 const double max_range = numeric_limits<double>::max()/10e-5;
+
+enum actions {MERGE, SPLIT};
 
 class polyhedron;
@@ -56 +58 @@
         vector<polyhedron*> neutralchildren;
 
+        bool totally_neutral;
+
         vector<polyhedron*> mergechildren;
 
@@ -76 +80 @@
 
                 message_counter = 0;
+
+                totally_neutral = NULL;
         }
         
@@ -101 +107 @@
                 return false;
         }
+
+        
 
         void set_state(double state_indicator, actions action)
@@ -143 +151 @@
         vec coordinates;        
 
-        enum actions {MERGE, SPLIT};
+        
 
 public:
@@ -207 +215 @@
                 multiplicity = 1;
         }
-}
+};
 
 
@@ -236 +244 @@
                         do
                         {
-                                product = (*vertex_ref)->coordinates*condition;
-                        }
-                        while(product == 0)
+                                product = (*vertex_ref)->get_coordinates()*condition;
+                        }
+                        while(product == 0);
 
                         if((product>0 && should_be_added)||(product<0 && !should_be_added))
@@ -319 +327 @@
                                         }
 
-                                        if(shouldsplit)
+                                        
+                                }
+
+                                if(shouldsplit)
                                         {
                                                 switch(sender->get_state(SPLIT))
@@ -328 +339 @@
                                                 case 0:
                                                         current_parent->neutralchildren.push_back(sender);
+
+                                                        if(current_parent->totally_neutral == NULL)
+                                                        {
+                                                                current_parent->totally_neutral = sender->totally_neutral;
+                                                        }
+                                                        else
+                                                        {
+                                                                current_parent->totally_neutral = current_parent->totally_neutral && sender->totally_neutral;
+                                                        }
+                                                        
                                                 break;
                                                 case -1:
@@ -336 +357 @@
                                                 if(is_last)
                                                 {
-                                                        if(current_parent->negativechildren.size()>0) 
+                                                        if((current_parent->negativechildren.size()>0&&current_parent->positivechildren.size()>0)||
+                                                                                                                (current_parent->neutralchildren.size()>0&&current_parent->totally_neutral==false))
                                                         {                                                               
-                                                                if(current_parent->positivechildren.size()>0)
-                                                                {
+                                                                
                                                                         for_splitting[level+1].push_back(current_parent);
                                                                 
                                                                         current_parent->set_state(0, SPLIT);
-                                                                }
-                                                                else 
-                                                                {
-                                                                        current_parent->set_state(-1, SPLIT);
-
-                                                                        current_parent->negativechildren.clear();
-                                                                        current_parent->neutralchildren.clear();
-                                                                }
+                                                        }
+                                                        else if(current_parent->negativechildren.size()>0)
+                                                        {
+                                                                current_parent->set_state(-1, SPLIT);
+
+                                                                current_parent->negativechildren.clear();
+                                                                current_parent->neutralchildren.clear();
+                                                                
                                                         }
                                                         else if(current_parent->positivechildren.size()>0)
@@ -372 +393 @@
                                                 send_state_message(current_parent,shouldsplit,shouldmerge,level+1);
                                         }
-                                }                       
                         
                         }
@@ -404 +424 @@
         }
 
-        void add_and_remove_condition(vec toremove, vec toadd)
-        {
+        void add_condition(vec toadd)
+        {
+                vec null_vector = "";
+
+                add_and_remove_condition(toadd, null_vector);
+        }
+
+        void remove_condition(vec toremove)
+        {
+                vec null_vector = "";
+
+                add_and_remove_condition(null_vector, toremove);
+        
+        }
+
+        void add_and_remove_condition(vec toadd, vec toremove)
+        {
+                bool should_remove = (toremove.size() != 0);
+                bool should_add    = (toadd.size() != 0);
+
                 vector<condition*>::iterator toremove_ref = conditions.end();
                 bool condition_should_be_added = false;
@@ -411 +449 @@
                 for(vector<condition*>::iterator ref = conditions.begin();ref<conditions.end();ref++)
                 {
-                        if(toremove != NULL)
+                        if(should_remove)
                         {
                                 if((*ref)->value == toremove)
                                 {
-                                        if(multiplicity>1)
-                                        {
-                                                multiplicity--;
+                                        if((*ref)->multiplicity>1)
+                                        {
+                                                (*ref)->multiplicity--;
 
                                                 alter_toprow_conditions(toremove,false);
 
-                                                toremove = NULL;
+                                                should_remove = false;
                                         }
                                         else
@@ -430 +468 @@
                         }
 
-                        if(toadd != NULL)
-                        {
-                                if((*iterator)->value == toadd)
+                        if(should_add)
+                        {
+                                if((*ref)->value == toadd)
                                 {
-                                        (*iterator)->multiplicity++;
+                                        (*ref)->multiplicity++;
 
                                         alter_toprow_conditions(toadd,true);
 
-                                        toadd = NULL;
+                                        should_add = false;
                                 }
                                 else
@@ -461 +499 @@
                 for(vector<polyhedron*>::iterator horizontal_position = statistic[0].begin();horizontal_position<statistic[0].end();horizontal_position++)
                 {               
-                        vertex* current_vertex = (vertex*)horizontal_position;
+                        vertex* current_vertex = (vertex*)(*horizontal_position);
                         
-                        if(toadd != NULL)
-                        {
-                                current_vertex->set_state(toadd*current_vertex->coordinates,SPLIT);
-                        }
+                        if(should_add||should_remove)
+                        {
+                                vec appended_vec = current_vertex->get_coordinates();
+                                appended_vec.ins(0,1.0);
+
+                                if(should_add)
+                                {
+                                        current_vertex->set_state(toadd*appended_vec,SPLIT);
+                                }
                         
-                        if(toremove != NULL)
-                        {
-                                current_vertex->set_state(toremove*current_vertex->coordinates,MERGE);
+                                if(should_remove)
+                                {
+                                        current_vertex->set_state(toremove*current_vertex->get_coordinates(),MERGE);
+                                }
 
                                 if(current_vertex->get_state(MERGE) == 0)
@@ -478 +522 @@
                         }
 
-                        send_state_message(current_vertex, toadd != NULL, toremove != NULL, 0);
-
-                        
-                }
+                        send_state_message(current_vertex, should_add, should_remove, 0);                       
+                }
+
+                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++)
+                        {
+                                polyhedron* current_polyhedron = (*vert_ref)[original_size-1-split_counter];
+
+
+                        }
+                }
+
+
         }
 
@@ -690 +746 @@
 };
 
+/*
+
 //! Robust Bayesian AR model for Multicriteria-Laplace-Inverse-Gamma density
 class RARX : public BM
@@ -707 +765 @@
         }
 
-};
+};*/
+