00001
00002
00003
00004
00005
00006
00007
00008
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "analysis.h"
00026
00027 Analysis::Analysis()
00028 {
00029 size_batch[EVEN]=3;
00030 size_batch[ODD]=2;
00031 converge=0;
00032 Max_samples[EVEN]=1200;
00033 Max_samples[ODD]=800;
00034 samples[EVEN]=0;
00035 samples[ODD]=0;
00036 position_batch[EVEN]=0;
00037 position_batch[ODD]=0;
00038 averages[EVEN][0]=0;
00039 averages[ODD][0]=0;
00040 batch[EVEN]=batch[ODD]=0;
00041 total_average=0;
00042 numerator_sy2=0;
00043 iter=0;
00044 }
00045
00046
00047
00048 bool Analysis::analyze(const long double &elem)
00049 {
00050
00051
00052
00053 bool finalized_iteration=0;
00054 long double rohatold;
00055 int end;
00056 averages[EVEN][batch[EVEN]]+=elem;
00057 averages[ODD][batch[ODD]]+=elem;
00058 position_batch[EVEN]+=1;
00059 position_batch[ODD]+=1;
00060
00061 if(position_batch[EVEN]==size_batch[EVEN]) {
00062
00063 averages[EVEN][batch[EVEN]]/=size_batch[EVEN];
00064
00065 batch[EVEN]+=1;
00066 position_batch[EVEN]=0;
00067 if(batch[EVEN]<NUM_BATCHES) averages[EVEN][batch[EVEN]]=0;
00068 }
00069 if(position_batch[ODD]==size_batch[ODD]) {
00070 averages[ODD][batch[ODD]]/=size_batch[ODD];
00071 batch[ODD]+=1;
00072 position_batch[ODD]=0;
00073 if(batch[ODD]<NUM_BATCHES) averages[ODD][batch[ODD]]=0;
00074 }
00075 samples[EVEN]+=1;
00076 samples[ODD]+=1;
00077
00078
00079
00080 if(samples[EVEN]==Max_samples[EVEN]) {
00081
00082 iter++;
00083 calculate_rohat(EVEN);
00084
00085
00086 Max_samples[EVEN]*=2;
00087 size_batch[EVEN]=Max_samples[EVEN]/NUM_BATCHES;
00088 calculate_averages(EVEN);
00089
00090 batch[EVEN]/=2;
00091 averages[EVEN][batch[EVEN]]=0;
00092
00093 if(rohat<=0) {
00094
00095 if(check_gamma()) {
00096 end=1;
00097 }
00098 else end=0;
00099 }
00100 else {
00101 if(0<rohat && rohat<THRESHOLD) {
00102
00103
00104
00105
00106
00107
00108
00109
00110 rohatold=rohat;
00111 calculate_rohat(EVEN,HALF);
00112
00113 if(rohat<rohatold && check_gamma()) {
00114
00115 end=1;
00116 }
00117 else end=0;
00118 }
00119 else end=0;
00120 }
00121 cout << "Iteration: " << iter << "\n";
00122 cout << " -> Result: "; result(); cout << "\n";
00123 finalized_iteration=1;
00124
00125
00126 if(end) {
00127 converge=1;
00128 return finalized_iteration;
00129 }
00130 }
00131
00132 if(samples[ODD]==Max_samples[ODD]) {
00133 iter++;
00134 calculate_rohat(ODD);
00135 Max_samples[ODD]*=2;
00136 size_batch[ODD]=Max_samples[ODD]/NUM_BATCHES;
00137 calculate_averages(ODD);
00138 batch[ODD]/=2;
00139 averages[ODD][batch[ODD]]=0;
00140 if(rohat<=0) {
00141 if(check_gamma()) {
00142 end=1;
00143 }
00144 else end=0;
00145 }
00146 else {
00147 if(0<rohat && rohat<THRESHOLD) {
00148 rohatold=rohat;
00149 calculate_rohat(ODD,HALF);
00150 if(rohat<rohatold && check_gamma()) {
00151 end=1;
00152 }
00153 else end=0;
00154 }
00155 else end=0;
00156 }
00157 cout << "Iteration: " << iter << "\n";
00158 cout << " -> Result: "; result(); cout << "\n";
00159 finalized_iteration=1;
00160 if(end) {
00161 converge=1;
00162 return finalized_iteration;
00163 }
00164 }
00165 return finalized_iteration;
00166 }
00167
00168 void Analysis::calculate_averages(int iteration)
00169 {
00170
00171
00172 register int i;
00173 register int k=0;
00174
00175 for(i=0;i<NUM_BATCHES/2;i++) {
00176
00177 averages[iteration][i]=averages[iteration][k]+averages[iteration][k+1];
00178 averages[iteration][i]/=2;
00179 k+=2;
00180 }
00181 return;
00182 }
00183
00184 int Analysis::calculate_rohat(int iteration,int which_part)
00185 {
00186
00187
00188
00189
00190 int number_batches=NUM_BATCHES/which_part;
00191 rohat=-0.5*(calculate_ro(iteration,number_batches,1)+calculate_ro(iteration,number_batches,2))+2*calculate_ro(iteration,number_batches,0);
00192 return 1;
00193
00194
00195 }
00196
00197 long double Analysis::calculate_ro(int iteration,int number_batches,int indicator)
00198 {
00199 int from=0;
00200 int to=number_batches;
00201 long double numerator=0;
00202 long double denominator=0;
00203 long double old=0;
00204 long double aux=0;
00205 register int i;
00206 switch (indicator) {
00207 case 1:
00208 to >>= 1;
00209 break;
00210 case 2:
00211 from = number_batches >> 1;
00212 break;
00213 }
00214
00215
00216 average_from_to(iteration,from,to);
00217 denominator=old=averages[iteration][from]-total_average;
00218 denominator*=denominator;
00219 for(i=from+1;i<=to-1;i++) {
00220 aux=averages[iteration][i]-total_average;
00221 numerator+=old*aux;
00222 denominator+=aux*aux;
00223 old=aux;
00224 }
00225 numerator_sy2=denominator;
00226 if(!denominator) {
00227 return 0;
00228 }
00229 numerator/=denominator;
00230 return numerator;
00231 }
00232
00233 void Analysis::average_from_to(int iteration,int from, int to)
00234 {
00235 register int i=0;
00236 total_average=0;
00237 for(i=from;i<to;i++) {
00238 total_average+=averages[iteration][i];
00239 }
00240 total_average/=(to-from);
00241 }
00242
00243 int Analysis::check_gamma()
00244 {
00245 long double delta;
00246 delta=t_STUDENT*sqrt(numerator_sy2/(NUM_BATCHES*(NUM_BATCHES-1)));
00247 if(total_average==0) {
00248 return 0;
00249
00250
00251
00252 }
00253 delta/=fabs(total_average);
00254
00255 if(delta>GAMMA) return 0;
00256
00257 return 1;
00258 }
00259
00260 void Analysis::result()
00261 {
00262 cout << total_average << "+-" << t_STUDENT*sqrt(numerator_sy2/(NUM_BATCHES*(NUM_BATCHES-1)));
00263 }
00264
00265 istream & operator >> (istream & ent, Analysis & anls)
00266 {
00267 return ent;
00268 }
00269
00270 ostream & operator << (ostream & sal, Analysis anls)
00271 {
00272 return sal;
00273 }