root/applications/robust/robustlib.cpp @ 1365

Revision 1365, 9.0 kB (checked in by sindj, 13 years ago)

Cele rozkopano a znovu poskladano za ucelem spravne integrace a nic - jen se mi podarilo doplnit faktor 1/2n. Sakris. JS

RevLine 
[976]1#include "robustlib.h"
2
[1282]3
[1335]4double polyhedron::triangulate(bool should_integrate)
[1273]5        {
[1324]6                for(set<simplex*>::iterator t_ref = triangulation.begin();t_ref!=triangulation.end();t_ref++)
7                {
8                        delete (*t_ref);
9                }               
[1301]10                triangulation.clear();
[1299]11
[1271]12                if(should_integrate)
13                {
14                        ((toprow *)this)->probability = 0.0;
15                }               
16               
[1301]17                if(vertices.size()==1)
18                {
[1324]19                        simplex* vert_simplex = new simplex((vertex*)this);                     
[1301]20
[1324]21                        triangulation.insert(vert_simplex);
[1301]22                }
23
[1254]24                for(list<polyhedron*>::iterator child_ref = children.begin();child_ref!=children.end();child_ref++)
[1271]25                {                       
[1324]26                        for(set<simplex*>::iterator s_ref = (*child_ref)->triangulation.begin();s_ref!=(*child_ref)->triangulation.end();s_ref++)
[1254]27                        {
[1324]28                                simplex* new_simplex = new simplex((*s_ref)->vertices);                                                         
[1301]29
[1324]30                                pair<set<vertex*>::iterator,bool> ret_val = new_simplex->vertices.insert(*vertices.begin());
[1301]31
32                                if(ret_val.second == true)
33                                {
[1320]34                                        double cur_prob = 0;
[1301]35
[1338]36                                        /*
37                                        if(should_integrate&&new_simplex->vertices.size()!=3)
38                                        {
39                                                cout << "Error: Wrong vertex count for integration!";
40                                        }
41                                        */
42
[1301]43                                        if(should_integrate)
44                                        {
[1320]45                                                cur_prob = ((toprow *)this)->integrate_simplex(new_simplex, 'S');
46
47                                                ((toprow *)this)->probability += cur_prob;
[1301]48                                        }
[1320]49
[1324]50                                        triangulation.insert(new_simplex);
51                                }
52                                else
53                                {
54                                        delete new_simplex;
55                                }
[1301]56                        }       
[1335]57                }       
58
59                if(should_integrate)
60                {
61                        return ((toprow *)this)->probability;
62                }
63                else
64                {
65                        return 0.0;
66                }
[1301]67               
68                /*
69                for(list<polyhedron*>::iterator child_ref = children.begin();child_ref!=children.end();child_ref++)
70                {                       
71                        for(list<set<vertex*>>::iterator t_ref = (*child_ref)->triangulation.begin();t_ref!=(*child_ref)->triangulation.end();t_ref++)
72                        {
73                                set<vertex*> new_simplex;
[1299]74                                new_simplex.insert((*t_ref).begin(),(*t_ref).end());                   
[1254]75
[1299]76                                for(set<vertex*>::iterator suitable_vert_ref = vertices.begin();*suitable_vert_ref<*(*t_ref).begin();suitable_vert_ref++)
77                                {
[1301]78                                        set<vertex*> suitable_simplex;
79                                        suitable_simplex.insert(new_simplex.begin(),new_simplex.end());
80                                       
81                                        suitable_simplex.insert(*suitable_vert_ref);
[1254]82
[1301]83                                        triangulation.push_back(suitable_simplex);
[1254]84
[1271]85                                        if(should_integrate)
[1254]86                                        {
[1301]87                                                ((toprow *)this)->probability += ((toprow *)this)->integrate_simplex(suitable_simplex, 'S');
[1271]88                                        }
[1299]89                                }                               
[1271]90                        }       
[1301]91                }*/             
[1271]92        }
[1268]93
94
[1324]95        double toprow::integrate_simplex(simplex* simplex, char c)
[1271]96        {
[1282]97                // cout << ((toprow*)this)->condition << endl;         
[1362]98                int sigma_order = ((toprow*)this)->condition_order-simplex->vertices.size()-1;
[1282]99
[1271]100                // cout << "C:" << condition_order << "  N:" << my_emlig->number_of_parameters << "  C+N:" << condition_order-my_emlig->number_of_parameters << endl;
101                // pause(0.1);
[1254]102
[1280]103                if(sigma_order >= 0)
[1271]104                {
[1275]105
[1282]106                        //cout << endl;
107                        //cout << ((toprow*)this)->condition << endl;
108                        //cout << "C:" << condition_order+2 << "  N:" << my_emlig->number_of_parameters << "  C+N:" << condition_order-my_emlig->number_of_parameters+2 << endl;
109                       
[1275]110
[1271]111                        emlig* current_emlig;
[1331]112                        simplex->clear_gammas();
[1254]113
[1271]114                        if(this->my_emlig!=NULL)
115                        {
116                                current_emlig = this->my_emlig;
117                        }
118                        else
119                        {
120                                throw exception("The statistic of the polyhedron you are trying to integrate over doesn't belong to any emlig!");
121                        }                                               
[1254]122
[1271]123                        toprow* as_toprow = (toprow*)this;
[1254]124
[1300]125                        vec cur_condition = as_toprow->condition_sum.get(1,as_toprow->condition_sum.size()-1);
[1254]126
[1275]127                        // cout << as_toprow->condition << endl;                       
[1272]128
[1324]129                        int dimension = simplex->vertices.size()-1;
[1254]130
[1275]131                        mat jacobian(dimension,dimension);                     
[1254]132
[1275]133                        double a_0;
[1271]134                        map<double,int> as;
[1275]135                        vertex* base_vertex;
[1324]136                        set<vertex*>::iterator base_ref = simplex->vertices.begin();
[1275]137                        bool order_correct;
138                                               
[1254]139
[1275]140                        do
[1271]141                        {
[1275]142                                order_correct = true;
143                                as.clear();
[1268]144
[1275]145                                base_vertex = (*base_ref);
[1282]146                       
[1362]147                                //cout << "Base coords: " << base_vertex->get_coordinates() << endl;
148                                //cout << "Condition: " << as_toprow->condition_sum << endl;
[1365]149                                //pause(0.1);
[1254]150
[1365]151                                a_0 = -base_vertex->get_coordinates()*cur_condition+as_toprow->condition_sum[0];               
[1282]152                               
[1275]153                                int row_count = 0;
[1324]154                                for(set<vertex*>::iterator vert_ref = simplex->vertices.begin(); vert_ref!=simplex->vertices.end();vert_ref++)
[1271]155                                {
[1275]156                                        if(vert_ref != base_ref)
157                                        {
[1276]158                                                vec relative_coords = (*vert_ref)->get_coordinates()-base_vertex->get_coordinates();                                           
[1275]159
160                                                jacobian.set_row(row_count,relative_coords);
161
[1281]162                                                double new_a = -relative_coords*cur_condition;
[1275]163
[1276]164                                                if(new_a + a_0 == 0 || new_a == 0)
[1275]165                                                {
166                                                        base_ref++;
167
[1357]168                                                        if(base_ref == simplex->vertices.end()&&simplex->vertices.size()!=2)
[1275]169                                                        {
170                                                                throw new exception("Equal local conditions are paired. If this ever occurs, the software has to be modified to include multiplied a_0!!");
171                                                        }
[1357]172                                                        /*
173                                                        else if(implex->vertices.size()==2)
174                                                        {
175                                                                return relative_coords[0]*exp
176                                                        }
177                                                        */
[1275]178                                                       
179                                                        order_correct = false;                                         
180
181                                                        break;
[1282]182                                                }                                               
183                                               
184                                               
185
[1335]186                                                if(a_0<current_emlig->min_ll)
[1282]187                                                {
188                                                        current_emlig->minimal_vertex = base_vertex;
[1335]189                                                        current_emlig->min_ll = a_0;
[1275]190                                                }
[1282]191
[1300]192                                                double a_m = (*vert_ref)->get_coordinates()*cur_condition-as_toprow->condition_sum[0];
[1335]193                                                if(a_m<current_emlig->min_ll)
[1282]194                                                {
195                                                        current_emlig->minimal_vertex = (*vert_ref);
[1335]196                                                        current_emlig->min_ll = a_m;                                           
[1282]197                                                }
198
199                                                //cout << "a0:" << a_0 << " a0 coords:" << base_vertex->get_coordinates() << " am:" << a_m << " am coords:" << (*vert_ref)->get_coordinates() << endl;
200
[1301]201                                                // cout << "Absolute coords:(V"  << row_count << ")" << (*vert_ref)->get_coordinates() << endl;
[1282]202                                                //cout << "Relative coords:(V"  << row_count << ")" << relative_coords << endl;
[1275]203
204                                                pair<map<double,int>::iterator,bool> returned = as.insert(pair<double,int>(new_a,1));
205                                                if(returned.second == false)
206                                                {
207                                                        (*returned.first).second++;
208                                                }
209                                                /*
210                                                else
211                                                {
212                                                        cout << "a[" << row_count << "] = " << new_a << endl;
213                                                }
214                                                */
215                                               
216                                                //as.ins(as.size(),new_a);                                                     
217                                               
218                                                row_count++;
219                                        }
[1271]220                                }
221                        }
[1275]222                        while(!order_correct);
[1272]223                       
[1282]224                        /*
[1281]225                        cout << "a_0: " << a_0 << "    ";
226                        int as_count = 1;
227                        for(map<double,int>::iterator as_ref = as.begin();as_ref!=as.end();as_ref++)
228                        {
229                                cout << "a_" << as_count << ": " << (*as_ref).first << "    ";
230                                as_count++;
[1365]231                        }
232                        */
[1269]233
[1335]234                        double int_value = 0;                   
[1268]235
[1271]236                        // cout << jacobian << endl;
[1268]237
[1272]238                        double det_jacobian    = abs(det(jacobian));
239                        double correction_term = det_jacobian;                 
[1271]240                        for(map<double,int>::iterator as_ref = as.begin();as_ref!=as.end();as_ref++)
241                        {
[1275]242                                double multiplier = det_jacobian;                               
[1272]243                               
[1275]244                                int as1_order = (*as_ref).second;
245                               
[1280]246                                correction_term /= pow(-(*as_ref).first,as1_order);                                     
[1275]247                               
248                                current_emlig->set_correction_factors(as1_order);
249
250                                vector<double> factors;
251                                int number_of_factors = 0;                                                             
252                                for(map<double,int>::iterator as2_ref = as.begin();as2_ref!=as.end();as2_ref++)
[1272]253                                {
254                                       
[1275]255                                        if(as2_ref!=as_ref)
256                                        {                                                                               
257                                                for(int k = 0;k<(*as2_ref).second;k++)
[1271]258                                                {
[1275]259                                                        factors.push_back((*as_ref).first-(*as2_ref).first);
[1272]260                                                }
[1270]261
[1275]262                                                multiplier        /= pow((*as_ref).first-(*as2_ref).first,(*as2_ref).second);
263                                                number_of_factors += (*as2_ref).second;
264                                        }
265                                        else
[1271]266                                        {
[1275]267                                                factors.push_back((*as_ref).first);
[1270]268
[1275]269                                                multiplier        /= (*as_ref).first;
270                                                number_of_factors += 1;
[1365]271                                        }                                       
272                                }       
[1254]273
[1365]274                                double gamma_multiplier = -(*as_ref).first-a_0;
275
276                                double bracket = fact(as1_order-1)/pow(gamma_multiplier,sigma_order+1);
[1331]277                                                               
[1365]278                                simplex->insert_gamma(0,bracket*multiplier,gamma_multiplier);                                                           
[1280]279
[1365]280                                // bracket *= fact(sigma_order);                               
[1325]281
[1275]282                                for(int k = 0;k < as1_order-1;k++)
283                                {
[1325]284                                        double local_bracket = 0;
[1365]285                                        double bracket_factor = 1/fact(as1_order-1-k)/pow(gamma_multiplier,sigma_order-k);//pow((double)-1,k+1)
[1272]286                                       
[1280]287                                        ivec control_vec = ivec();
[1325]288                                        control_vec.ins(0,my_emlig->number_of_parameters-as1_order+1);                                 
[1280]289                                       
290                                        for(multiset<my_ivec>::iterator combi_ref = this->my_emlig->correction_factors[k].begin();combi_ref!=this->my_emlig->correction_factors[k].upper_bound(my_ivec(control_vec));combi_ref++)
[1275]291                                        {
292                                                double bracket_combination = 1;
[1280]293                                                for(int j = 0;j<(*combi_ref).size();j++)
[1275]294                                                {
[1281]295                                                        //cout << "Factor vector:" << (*combi_ref) << endl;
[1280]296                                                       
297                                                        bracket_combination /= factors[(*combi_ref)[j]-1];
[1325]298                                                }                                               
299                                                                                               
300                                                local_bracket += bracket_factor*bracket_combination;                                                                   
301                                        }
[1254]302
[1365]303                                        simplex->insert_gamma(k+1,local_bracket*multiplier,gamma_multiplier);
[1349]304
305                                        int division_factor = 1;
306                                        for(int s = 0;s<k;s++)
307                                        {
308                                                division_factor *= k-s;
309                                        }
[1325]310                                       
[1349]311                                        bracket += local_bracket/division_factor; //local_bracket*fact(sigma_order-k);
[1325]312                                }                               
313
[1275]314                                int_value += multiplier*bracket;
[1365]315
316                               
[1275]317                                                                                                                                               
[1272]318                        }
[1271]319
[1365]320                        double correction_term_base = correction_term/pow(-a_0,sigma_order+1);
[1271]321
[1365]322                        simplex->insert_gamma(0,correction_term_base,-a_0);                     
[1272]323
[1349]324                        correction_term = correction_term_base;//fact(sigma_order)*correction_term_base;
[1325]325
326                        //cout << c << int_value << endl;
327
[1365]328                        int_value += correction_term;                   
[1272]329
[1325]330                        //cout << "Probability:" << int_value << endl;
331                        //pause(0.100);
[1272]332
[1324]333                        simplex->probability = int_value;
[1271]334                       
[1324]335                        return int_value;       
[1275]336                       
[1271]337                }
338                else
339                {
[1362]340                        cout << "Improper probability density." << endl;
[1271]341                        return 0.0;
342                }
[1254]343        }
Note: See TracBrowser for help on using the browser.