Changeset 1282 for applications

Show
Ignore:
Timestamp:
02/21/11 09:22:08 (13 years ago)
Author:
sindj
Message:

Prvni pokusy s robustnim AR modelem. JS

Location:
applications/robust
Files:
3 modified

Legend:

Unmodified
Added
Removed
  • applications/robust/main.cpp

    r1281 r1282  
    99#include "robustlib.h" 
    1010#include <vector> 
     11#include <iostream> 
     12#include <fstream> 
     13 
    1114using namespace itpp; 
    12  
    1315//using namespace bdm; 
    1416 
     
    1820int main ( int argc, char* argv[] ) { 
    1921         
    20  
    21         emlig* emlig1 = new emlig(emlig_size); 
     22         
     23         
     24         
     25        vector<vector<vector<string>>> string_lists; 
     26        string_lists.push_back(vector<vector<string>>()); 
     27        string_lists.push_back(vector<vector<string>>()); 
     28        string_lists.push_back(vector<vector<string>>()); 
     29 
     30        char* file_strings[3] = {"c:\\ar_normal.txt", "c:\\ar_student.txt", "c:\\ar_cauchy.txt"}; 
     31         
     32 
     33        for(int i = 0;i<3;i++) 
     34        {        
     35                ifstream myfile(file_strings[i]); 
     36                if (myfile.is_open()) 
     37                { 
     38                        while ( myfile.good() ) 
     39                        { 
     40                                string line; 
     41                                getline(myfile,line); 
     42                                 
     43                                vector<string> parsed_line; 
     44                                while(line.find(',') != string::npos) 
     45                                { 
     46                                        int loc = line.find(','); 
     47                                        parsed_line.push_back(line.substr(0,loc)); 
     48                                        line.erase(0,loc+1);                                     
     49                                }                                
     50 
     51                                string_lists[i].push_back(parsed_line); 
     52                        } 
     53                        myfile.close(); 
     54                } 
     55        } 
     56 
     57        for(int j = 0;j<string_lists.size();j++) 
     58        {  
     59                 
     60                for(int i = 0;i<string_lists[j].size();i++) 
     61                { 
     62                        vector<vec> conditions; 
     63                        emlig* emliga = new emlig(2); 
     64                        for(int k = 1;k<string_lists[j][i].size();k++) 
     65                        { 
     66                                vec condition; 
     67                                //condition.ins(0,1);                            
     68                                condition.ins(0,string_lists[j][i][k]);                          
     69                                conditions.push_back(condition); 
     70 
     71                                //cout << "orig:" << condition << endl; 
     72 
     73                                if(conditions.size()>1) 
     74                                {                
     75                                        conditions[k-2].ins(0,string_lists[j][i][k]); 
     76                                         
     77                                } 
     78 
     79                                if(conditions.size()>2) 
     80                                { 
     81                                        conditions[k-3].ins(0,string_lists[j][i][k]); 
     82 
     83                                        //cout << "modi:" << conditions[k-3] << endl; 
     84 
     85                                        emliga->add_condition(conditions[k-3]); 
     86 
     87                                        /* 
     88                                        if(k>5) 
     89                                        { 
     90                                                cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl; 
     91                                        } 
     92                                        */ 
     93                                } 
     94                        } 
     95 
     96                        //emliga->step_me(0); 
     97                        cout << "MaxLik coords:" << emliga->minimal_vertex->get_coordinates() << endl; 
     98                        cout << "Step: " << i << endl; 
     99                } 
     100 
     101                cout << "One experiment finished." << endl; 
     102        } 
     103 
     104         
     105 
     106        //emlig* emlig1 = new emlig(emlig_size); 
    22107         
    23108        /* 
     
    39124        }*/ 
    40125         
    41         vec condition1 = "1.0 1.0 1.0"; 
     126    /* 
     127        vec condition1 = "1.0 1.0 1.01"; 
    42128        emlig1->add_condition(condition1); 
    43129 
     
    45131        emlig1->add_condition(condition2); 
    46132 
    47         vec condition3 = "0.5 -1.1 1.0"; 
     133        vec condition3 = "0.5 -1.01 1.0"; 
    48134        emlig1->add_condition(condition3); 
    49135 
     
    51137        emlig1->add_condition(condition4); 
    52138 
    53         vec condition5 = "-0.3 1.7 1.5"; 
    54         emlig1->add_condition(condition5); 
    55  
     139        cout << emlig1->minimal_vertex->get_coordinates(); 
     140 
     141        //vec condition5 = "-0.3 1.7 1.5"; 
     142        //emlig1->add_condition(condition5); 
     143 
     144        // DA SE POUZIT PRO VYPIS DO SOUBORU 
    56145        // emlig1->step_me(0); 
    57146 
     
    61150 
    62151         
    63  
    64152        /* 
    65         for(int i = 0;i<500;i++) 
    66         { 
    67                 cout << endl << "Step:" << i << endl; 
    68                  
    69                  
     153         
     154        for(int i = 0;i<100;i++) 
     155        { 
     156                cout << endl << "Step:" << i << endl;            
    70157 
    71158                double condition[emlig_size+1];          
     
    139226} 
    140227 
     228 
     229 
  • applications/robust/robustlib.cpp

    r1281 r1282  
    11#include "robustlib.h" 
     2 
    23 
    34void polyhedron::triangulate(bool should_integrate) 
     
    3334        double toprow::integrate_simplex(set<vertex*> simplex, char c) 
    3435        { 
    35                 // cout << ((toprow*)this)->condition << endl; 
    36                  
     36                // cout << ((toprow*)this)->condition << endl;           
     37 
    3738                int condition_order = ((toprow*)this)->condition_order-2; // -2 by bylo, pokud chceme uniformni apriorno 
    3839 
     
    4546                { 
    4647 
    47                         cout << endl; 
    48                         cout << ((toprow*)this)->condition << endl; 
    49                         cout << "C:" << condition_order+2 << "  N:" << my_emlig->number_of_parameters << "  C+N:" << condition_order-my_emlig->number_of_parameters+2 << endl; 
     48                        //cout << endl; 
     49                        //cout << ((toprow*)this)->condition << endl; 
     50                        //cout << "C:" << condition_order+2 << "  N:" << my_emlig->number_of_parameters << "  C+N:" << condition_order-my_emlig->number_of_parameters+2 << endl; 
     51                         
    5052 
    5153                        emlig* current_emlig; 
     
    8486                                base_vertex = (*base_ref); 
    8587 
    86                                 cout << "Base coords:" << base_vertex->get_coordinates() << endl; 
     88                         
     89                                //cout << endl << "Base coords:" << base_vertex->get_coordinates() << endl; 
    8790 
    8891                                a_0 = base_vertex->get_coordinates()*cur_condition-as_toprow->condition[0]; 
     92                                 
    8993 
    9094                                int row_count = 0; 
     
    111115 
    112116                                                        break; 
    113                                                 } 
    114                                                  
     117                                                }                                                
     118                                                 
     119                                                 
     120 
     121                                                if(a_0<current_emlig->likelihood_value) 
     122                                                { 
     123                                                        current_emlig->minimal_vertex = base_vertex; 
     124                                                        current_emlig->likelihood_value = a_0; 
     125                                                } 
     126 
     127                                                double a_m = (*vert_ref)->get_coordinates()*cur_condition-as_toprow->condition[0]; 
     128                                                if(a_m<current_emlig->likelihood_value) 
     129                                                { 
     130                                                        current_emlig->minimal_vertex = (*vert_ref); 
     131                                                        current_emlig->likelihood_value = a_m;                                           
     132                                                } 
     133 
     134                                                //cout << "a0:" << a_0 << " a0 coords:" << base_vertex->get_coordinates() << " am:" << a_m << " am coords:" << (*vert_ref)->get_coordinates() << endl; 
     135 
    115136                                                //cout << "Absolute coords:(V"  << row_count << ")" << (*vert_ref)->get_coordinates() << endl; 
    116                                                 cout << "Relative coords:(V"  << row_count << ")" << relative_coords << endl; 
     137                                                //cout << "Relative coords:(V"  << row_count << ")" << relative_coords << endl; 
    117138 
    118139                                                pair<map<double,int>::iterator,bool> returned = as.insert(pair<double,int>(new_a,1)); 
     
    136157                        while(!order_correct); 
    137158                         
     159                        /* 
    138160                        cout << "a_0: " << a_0 << "    "; 
    139161                        int as_count = 1; 
     
    142164                                cout << "a_" << as_count << ": " << (*as_ref).first << "    "; 
    143165                                as_count++; 
    144                         } 
     166                        }*/ 
    145167 
    146168                        double int_value = 0; 
     
    224246                 
    225247 
    226                         cout << "Probability:" << int_value << endl; 
     248                        //cout << "Probability:" << int_value << endl; 
    227249                         
    228250                        return int_value; 
  • applications/robust/robustlib.h

    r1281 r1282  
    2121using namespace itpp; 
    2222 
    23 const double max_range = 10.0;//numeric_limits<double>::max()/10e-10; 
     23const double max_range = 10;//numeric_limits<double>::max()/10e-10; 
    2424 
    2525enum actions {MERGE, SPLIT}; 
     26 
     27 
    2628 
    2729class polyhedron; 
     
    187189{ 
    188190        /// A dynamic array representing coordinates of the vertex 
    189         vec coordinates;         
    190  
    191          
     191        vec coordinates; 
    192192 
    193193public: 
    194194 
    195  
     195        double function_value; 
    196196 
    197197        /// Default constructor 
     
    238238        double probability; 
    239239 
     240        vertex* minimal_vertex; 
     241 
    240242        /// A condition used for determining the function of a Laplace-Inverse-Gamma density resulting from Bayesian estimation 
    241243        vec condition; 
     
    589591 
    590592        double normalization_factor; 
     593 
     594         
    591595 
    592596        void alter_toprow_conditions(vec condition, bool should_be_added) 
     
    802806        c_statistic statistic; 
    803807 
     808        vertex* minimal_vertex; 
     809 
     810        double likelihood_value; 
     811 
    804812        vector<multiset<my_ivec>> correction_factors; 
    805813 
     
    812820                this->number_of_parameters = number_of_parameters; 
    813821 
    814                 create_statistic(number_of_parameters);          
     822                create_statistic(number_of_parameters); 
     823 
     824                likelihood_value = numeric_limits<double>::max(); 
    815825        } 
    816826 
     
    819829        emlig(c_statistic statistic) 
    820830        { 
    821                 this->statistic = statistic;             
     831                this->statistic = statistic;     
     832 
     833                likelihood_value = numeric_limits<double>::max(); 
    822834        } 
    823835 
    824836        void step_me(int marker) 
    825837        { 
     838                 
    826839                for(int i = 0;i<statistic.size();i++) 
    827840                { 
     
    836849                        } 
    837850                } 
     851 
     852                /* 
     853                list<vec> table_entries; 
     854                for(polyhedron* horiz_ref = statistic.rows[statistic.size()-1];horiz_ref!=statistic.row_ends[statistic.size()-1];horiz_ref=horiz_ref->next_poly) 
     855                { 
     856                        toprow *current_toprow = (toprow*)(horiz_ref); 
     857                        for(list<set<vertex*>>::iterator tri_ref = current_toprow->triangulation.begin();tri_ref!=current_toprow->triangulation.end();tri_ref++) 
     858                        { 
     859                                for(set<vertex*>::iterator vert_ref = (*tri_ref).begin();vert_ref!=(*tri_ref).end();vert_ref++) 
     860                                { 
     861                                        vec table_entry = vec(); 
     862                                         
     863                                        table_entry.ins(0,(*vert_ref)->get_coordinates()*current_toprow->condition.get(1,current_toprow->condition.size()-1)-current_toprow->condition.get(0,0)); 
     864                                         
     865                                        table_entry.ins(0,(*vert_ref)->get_coordinates()); 
     866 
     867                                        table_entries.push_back(table_entry); 
     868                                } 
     869                        }                        
     870                } 
     871 
     872                unique(table_entries.begin(),table_entries.end()); 
     873 
     874                                 
     875                 
     876                for(list<vec>::iterator entry_ref = table_entries.begin();entry_ref!=table_entries.end();entry_ref++) 
     877                { 
     878                        ofstream myfile; 
     879                        myfile.open("robust_data.txt", ios::out | ios::app); 
     880                        if (myfile.is_open()) 
     881                        { 
     882                                for(int i = 0;i<(*entry_ref).size();i++) 
     883                                { 
     884                                        myfile << (*entry_ref)[i] << ";"; 
     885                                } 
     886                                myfile << endl; 
     887                         
     888                                myfile.close(); 
     889                        } 
     890                        else 
     891                        { 
     892                                cout << "File problem." << endl; 
     893                        } 
     894                } 
     895                */ 
     896                 
     897 
     898                return; 
    838899        } 
    839900 
     
    862923        void add_and_remove_condition(vec toadd, vec toremove) 
    863924        { 
     925                likelihood_value = numeric_limits<double>::max(); 
     926 
    864927                bool should_remove = (toremove.size() != 0); 
    865928                bool should_add    = (toadd.size() != 0);