Changeset 1267 for applications/robust

Timestamp:

12/21/10 18:28:55 (13 years ago)

Author:

sindj

Message:

Dodelavka funkce vytvarejici kombinaci faktoru integrace pri degeneraci podminek ve vice vrcholech polyhedronu. JS

Location:

applications/robust

Files:

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

applications/robust/main.cpp

@@ -15 +15 @@
 int main ( int argc, char* argv[] ) {
         
-        emlig* emlig1 = new emlig(3);
+        emlig* emlig1 = new emlig(4);
 
-        emlig1->set_correction_factors(3);
+        /*
+        emlig1->set_correction_factors(4);
+
+        for(int j = 0;j<emlig1->correction_factors.size();j++)
+        {
+                for(set<my_ivec>::iterator vec_ref = emlig1->correction_factors[j].begin();vec_ref!=emlig1->correction_factors[j].end();vec_ref++)
+                {
+                        for(int i=0;i<(*vec_ref).size();i++)
+                        {
+                                cout << (*vec_ref)[i];
+                        }
+
+                        cout << endl;
+                }
+        }
+        */
 
         //emlig1->step_me(0);

applications/robust/robustlib.h

@@ -251 +251 @@
 };
 
+
 class condition
 {       
@@ -265 +266 @@
 };
 
+
+
+
 class c_statistic
 {
@@ -410 +414 @@
         }
 };
+
+
+class my_ivec : public ivec
+{
+public:
+        my_ivec():ivec(){};
+
+        my_ivec(ivec origin):ivec()
+        {
+                this->ins(0,origin);
+        }
+
+        bool operator>(const my_ivec &second) const
+        {
+                int size1 = this->size();
+                int size2 = second.size();
+                 
+                int counter1 = 0;
+                while(0==0)
+                {
+                        if((*this)[counter1]==0)
+                        {
+                                size1--;
+                        }
+                        
+                        if((*this)[counter1]!=0)
+                                break;
+
+                        counter1++;
+                }
+
+                int counter2 = 0;
+                while(0==0)
+                {
+                        if(second[counter2]==0)
+                        {
+                                size2--;
+                        }
+                        
+                        if(second[counter2]!=0)
+                                break;
+
+                        counter2++;
+                }
+
+                if(size1!=size2)
+                {
+                        return size1>size2;
+                }
+                else
+                {
+                        for(int i = 0;i<size1;i++)
+                        {
+                                if((*this)[counter1+i]!=second[counter2+i])
+                                {
+                                        return (*this)[counter1+i]>second[counter2+i];
+                                }
+                        }
+
+                        return false;
+                }
+        }
+
+        
+        bool operator==(const my_ivec &second) const
+        {
+                int size1 = this->size();
+                int size2 = second.size();
+                 
+                int counter = 0;
+                while(0==0)
+                {
+                        if((*this)[counter]==0)
+                {
+                        size1--;
+                }
+                        
+                if((*this)[counter]!=0)
+                        break;
+
+                counter++;
+                }
+
+                counter = 0;
+                while(0==0)
+                {
+                        if(second[counter]==0)
+                        {
+                                size2--;
+                        }
+                        
+                        if(second[counter]!=0)
+                                break;
+
+                        counter++;
+                }
+
+                if(size1!=size2)
+                {
+                        return false;
+                }
+                else
+                {
+                        for(int i=0;i<size1;i++)
+                        {
+                                if((*this)[size()-1-i]!=second[second.size()-1-i])
+                                {
+                                        return false;
+                                }
+                        }
+
+                        return true;
+                }
+        }
+
+        bool operator<(const my_ivec &second) const
+        {
+                return !(((*this)>second)||((*this)==second));
+        }
+
+        bool operator!=(const my_ivec &second) const
+        {
+                return !((*this)==second);
+        }
+
+        bool operator<=(const my_ivec &second) const
+        {
+                return !((*this)>second);
+        }
+
+        bool operator>=(const my_ivec &second) const
+        {
+                return !((*this)<second);
+        }
+
+        my_ivec right(my_ivec original)
+        {
+                
+        }
+};
+
 
 
@@ -628 +773 @@
 public: 
 
-        vector<set<ivec>> correction_factors;
+        vector<set<my_ivec>> correction_factors;
 
         int number_of_parameters;
@@ -929 +1074 @@
         void set_correction_factors(int order)
                 {
-                        for(int remaining_order = correction_factors.size();remaining_order>order;remaining_order++)
-                        {
-                                set<ivec> factor_templates;
-                                set<ivec> final_factors;
+                        for(int remaining_order = correction_factors.size();!(remaining_order>order);remaining_order++)
+                        {
+                                set<my_ivec> factor_templates;
+                                set<my_ivec> final_factors;
 
                                 
-                                for(int i = 1;i==number_of_parameters-order+1;i++)
+                                for(int i = 1;i!=number_of_parameters-order+1;i++)
                                 {                                       
-                                        ivec new_template = vec_2(1,i);
-                                        //new_template[0]=1;
-                                        //new_template[1]=i;
-                                        //factor_templates.insert(new_template);
+                                        my_ivec new_template = my_ivec();
+                                        new_template.ins(0,1);
+                                        new_template.ins(1,i);
+                                        factor_templates.insert(new_template);
 
                                         
-                                        for(int j = 1;j==remaining_order-1;j++)
+                                        for(int j = 1;j<remaining_order;j++)
                                         {
                                                 
-                                                for(set<ivec>::iterator fac_ref = factor_templates.begin();fac_ref!=factor_templates.end();fac_ref++)
+                                                for(set<my_ivec>::iterator fac_ref = factor_templates.begin();fac_ref!=factor_templates.end();fac_ref++)
                                                 {
                                                         ivec current_template = (*fac_ref);
@@ -1286 +1431 @@
 };*/
 
- bool ivec::operator>(const ivec &first, const ivec &second) 
- {
-         int size1 = first.size();
-         int size2 = second.size();
-         
-         int counter1 = 0;
-         while(0==0)
-         {
-                 if(first[counter1]==0)
-                 {
-                        size1--;
-                 }
-                
-                 if(first[counter1]!=0)
-                         break;
-         }
-
-         int counter2 = 0;
-         while(0==0)
-         {
-                 if(second[counter2]==0)
-                 {
-                        size2--;
-                 }
-                
-                 if(second[counter2]!=0)
-                         break;
-         }
-
-         if(size1!=size2)
-         {
-                return size1>size2;
-         }
-         else
-         {
-                 for(int i = 0;i<size1;i++)
-                 {
-                         if(first[counter1+i]!=second[counter2+i])
-                         {
-                                return first[counter1+i]>second[counter2+i]
-                         }
-                 }
-
-                 return false;
-         }
- }
+
+
+
+
+
+