Diploma Thesis Percolation Simulation C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code

                 

---

ff Namespace Reference

Compounds
class	arguments1
class	fillingfactor_functions
Typedefs
typedef measure< REAL >	measuredouble
Functions
bool	is_there_a_spanning_cluster (REAL ff, arguments1 &arg)
int	bracket_ff (bool(*f)(REAL, arguments1 &), arguments1 &arg, REAL left, REAL right, REAL tol, measuredouble &result)
int	find_one_ffc (REAL left, REAL right, REAL tol, sphere *spheres, NUMLIST &L_sph, string &throwtime, const char *clusteranalysis_file, measuredouble &one_ffc, clock_t &brackettime)
bool	find_mean_ffc (NUMBER N, int dim, COUNTER at_least, REAL mean_tolerance, REAL left, REAL right, REAL loose_tolerance, const char *clusteranalysis_file, const char *bestresults_file, muvarskewkurt< REAL > &result_ffc, minmax &result_minmax)
void	find_ffc_scanning_N_and_dim (int lowerdim, int upperdim, REAL lower_N, NUMBER upper_N, REAL tolerance, COUNTER at_least)
void	find_ffc_frontend ()
int	find_one_ff_with_criterion (bool(*criterion)(REAL, arguments1 &), REAL parameter, REAL left, REAL right, REAL tol, sphere *spheres, NUMLIST &L_sph, string &throwtime, const char *clusteranalysis_file, measuredouble &one_ff, clock_t &brackettime)
bool	find_mean_ff_with_criterion (bool(*criterion)(REAL, arguments1 &), REAL parameter, string namecriterion, REAL(*ff_guessed)(NUMBER, int, REAL), NUMBER N, int dim, COUNTER at_least, REAL accuracy, REAL left, REAL right, REAL loose_tolerance, const char *clusteranalysis_file, const char *bestresults_file, muvarskewkurt< REAL > &result_ff, minmax &result_minmax)
void	find_ff_with_criterion_scanning_N_and_dim (bool(*criterion)(REAL, arguments1 &), REAL parameter, string namecriterion, REAL(*ff_guessed)(NUMBER, int, REAL), int lowerdim, int upperdim, REAL lower_N, NUMBER upper_N, REAL tolerance, COUNTER at_least)
bool	is_there_only_one_cluster (REAL ff, arguments1 &arg)
REAL	ff_all_in1clst_guessed (NUMBER N, int dim, REAL ratio)
bool	is_the_numberofcl_smaller_than_a_ratio (REAL ff, arguments1 &arg)
REAL	ffnoc_guessed (NUMBER N, int dim, REAL ratio)
bool	is_the_biggestcluster_bigger_than_a_ratio (REAL ff, arguments1 &arg)
REAL	ffbig_guessed (NUMBER N, int dim, REAL ratio)
bool	is_the_incl_meancluster_bigger_than_a_ratio (REAL ff, arguments1 &arg)
REAL	ffmean1_guessed (NUMBER N, int dim, REAL ratio)
void	load_stepfunctions (fillingfactor_functions *stepfn)
fillingfactor_functions	give_one_stepfunction (int num)
void	find_ff_with_criterion_frontend ()
Variables
const int	N_STEPFN = 5

---

Typedef Documentation

typedef measure<REAL> ff::measuredouble

Definition at line 21 of file ff.h. Referenced by bracket_ff().

---

Function Documentation

int bracket_ff (  bool(*    f)(REAL, arguments1 &), arguments1 &    arg, REAL    left, REAL    right, REAL    tol, measuredouble &    result )

Definition at line 76 of file ff.h. References ASCII_PLUSMINUS, measuredouble, and REAL. Referenced by find_one_ff_with_criterion(), and find_one_ffc(). { REAL l,m,r; bool fl,fm,fr; l=left; r=right; // if (l>r) swap(l, r); // ATTENTION: ok this way? if (l>r) return 2; // fl=f(l,arg); if (fl==true) return -1; // missed left (percolates already at left bracket of interval) if (l==r) return (fl==true)?-1:+1; // the percolationpoint is left:right of point==intervall fr=f(r,arg); if (fr==false) return +1; // missed right (percolates already at right bracket of interval) m=l+(r-l)/2; // middle is the best guess while (r-l>tol){ fm=f(m,arg); if (fm==1){ r=m; fr=fm; } else { l=m; fr=fm; } m=l+(r-l)/2; cout << "m= "<<m<<ASCII_PLUSMINUS<<(r-l)/2<<" "<<flush; } result=measuredouble (m, (r-l)/2); return 0; // and result }

REAL ff_all_in1clst_guessed (  NUMBER    N, int    dim, REAL    ratio )

Definition at line 555 of file ff.h. References NUMBER, REAL, and saturating_fillingfactor(). Referenced by load_stepfunctions(). { return saturating_fillingfactor(dim,N); }

REAL ffbig_guessed (  NUMBER    N, int    dim, REAL    ratio )

Definition at line 591 of file ff.h. References ff_critical_guessed(), NUMBER, and REAL. Referenced by load_stepfunctions(). { return (1+ratio) * ff_critical_guessed(N, dim); }

REAL ffmean1_guessed (  NUMBER    N, int    dim, REAL    ratio )

Definition at line 605 of file ff.h. References ff_critical_guessed(), NUMBER, and REAL. Referenced by load_stepfunctions(). { return (1+ratio) * ff_critical_guessed(N, dim); }

REAL ffnoc_guessed (  NUMBER    N, int    dim, REAL    ratio )

Definition at line 570 of file ff.h. References ff_critical_guessed(), fillingfactor_noc1percent(), NUMBER, and REAL. Referenced by load_stepfunctions(). { // TODO: // interpolation between noc1% and noc90% // if (ratio==0.01) return fillingfactor_noc1percent(dim,N); else{ if (ratio >0.2) return 0.5*ff_critical_guessed(N, dim); else return 1.5*ff_critical_guessed(N, dim); } }

void find_ff_with_criterion_frontend (    )

Definition at line 657 of file ff.h. References COUNTER, find_ff_with_criterion_scanning_N_and_dim(), ff::fillingfactor_functions::fn, load_stepfunctions(), log(), MAXDIM, MAXNUMBER, N_STEPFN, ff::fillingfactor_functions::name, NUMBER, REAL, rounded(), and ff::fillingfactor_functions::theory. Referenced by main(). { cout<<"Fillingfactor-Fillingstation - Hello in parameter-space!\n\n"; cout<<"\nPlease type in the range of N (number of spheres) you are interested in."<<endl; cout<<"The lower number will be doubled while <= the upper number."<<endl; cout<<"Attention: The algorithm is optimized for these N only:"<<endl; cout<<"312(type in 312.5), 625, 1250, 2500, 5000, 10000, 20000, 40000, 80000, 160000, 320000"; cout<<endl; REAL lower_N=78; NUMBER upper_N=MAXNUMBER; do{ cout<<"[1..."<<MAXNUMBER<<", 1..."<<MAXNUMBER<<"] "; cin >> lower_N>>upper_N; }while (lower_N>upper_N || lower_N<1 || upper_N<1 || lower_N>MAXNUMBER ||upper_N>MAXNUMBER); cout<<"\nThanks.\nYou can now choose, which fillingfactor you want to find out:\nI want the mean\n"; cout<<"(1) critical fillingfactor (spanning-cluster from left to right)\n"; cout<<"(2) ff for which every single sphere belongs to the one big cluster\n"; cout<<"(3) ff for which the number-of-clusters == given percentage of the # of spheres\n"; cout<<"(4) ff for which the size of the biggest-cluster == given percentage of the # of spheres\n"; cout<<"(5) ff for which the mean-clustersize == given percentage of the # of spheres\n"; cout<<"Choose a number: "; int criterion=1; do { cin>>criterion; } while (criterion < 1 || criterion >5); cout<<"Thanks. So be it.\n"; char buffer[5]; sprintf(buffer, "", ""); REAL percent=50; if (criterion>2){ cout<<"Now please give the percentage"; REAL percent_step=100/(REAL)lower_N; do{ cout<<"[ "<<percent_step<<"% ; "<<100-percent_step<<"% ] "; cin >>percent; } while (percent<percent_step || percent>100-percent_step); if (percent<10) sprintf(buffer, "%1.0f%c", percent,'%'); else sprintf(buffer, "%2.0f%c", percent,'%'); } fillingfactor_functions stepfn[N_STEPFN+1]; load_stepfunctions(stepfn); string namecriterion =stepfn[criterion].name+buffer; bool (* stepfn_criterion)(REAL, arguments1&)=stepfn[criterion].fn; REAL (* ff_guessed)(NUMBER,int,REAL) =stepfn[criterion].theory; cout<<"OK. GREAT! You have chosen ("<<criterion<<") >> "<<namecriterion<<" << Please remember this!"; cout<<"\n\n ... the simulation will take some time."<<endl; cout<<"The higher your wanted dimension, the slower (above dim~7 really dramatic!)!"<<endl; cout<<"Please now type in the range of dimensions you are interested in"<<endl; int lowerdim=1, upperdim=MAXDIM; do{ cout<<"[1..."<<MAXDIM<<", 1..."<<MAXDIM<<"] "; cin >> lowerdim>>upperdim; }while(lowerdim>upperdim || lowerdim<1 || upperdim<1 || lowerdim>MAXDIM ||upperdim>MAXDIM); cout<<"Very good.\nNow...how good shall the result be?"; cout<<"\nPlease type in the target accuracy in %"; REAL tol=5; do{ cout<<"[0.1 ... 50]"; cin >> tol; }while (tol<0.01 || tol>50 ); tol/=100.0; cout<<"OK.\nNow...how many ff-values shall there be AT LEAST for each configuration?"; cout<<"\nPlease type e.g. in 30 for high N, 70 for low N: "; COUNTER at_least=50; do{ cout<<"[0 ... 150] "; cin >> at_least; }while (at_least<1); cout<<"\nOK, now you can switch off the monitor to save energy..."<<endl; COUNTER confs=rounded(log((REAL)upper_N/lower_N)/log(2.0)+1)*(upperdim-lowerdim+1); cout<<"I will simulate these "<<confs<<" configurations and save the results to disk"<<endl; find_ff_with_criterion_scanning_N_and_dim(stepfn_criterion, percent/100, namecriterion, ff_guessed, lowerdim, upperdim, lower_N, upper_N, tol, at_least); }

void find_ff_with_criterion_scanning_N_and_dim (  bool(*    criterion)(REAL, arguments1 &), REAL    parameter, string    namecriterion, REAL(*    ff_guessed)(NUMBER, int, REAL), int    lowerdim, int    upperdim, REAL    lower_N, NUMBER    upper_N, REAL    tolerance, COUNTER    at_least )

Definition at line 485 of file ff.h. References COUNTER, datafiles::create_clusteranalysis_resultfile(), datafiles::create_ff_bestresults_file(), FILEHEAD2, find_mean_ff_with_criterion(), heat_random_generator(), NUMBER, REAL, SEED7, and timestamp_fullyear(). Referenced by find_ff_with_criterion_frontend(), and commandline::start_subprg(). { srand( SEED7 ); // set the random generator to a seed cout <<endl; heat_random_generator(); cout <<endl; // write File-Intro to bracket-results string clusteranalysis_file=""; clusteranalysis_file=(clusteranalysis_file+FILEHEAD2)+"single-results-" +timestamp_fullyear()+".txt"; create_clusteranalysis_resultfile(clusteranalysis_file.c_str(), namecriterion); // write File-Intro to best results string bestresults_file=""; bestresults_file=bestresults_file+FILEHEAD2+"best-results_"+namecriterion+"_"+timestamp_fullyear()+".txt"; create_ff_bestresults_file(bestresults_file.c_str(), namecriterion); REAL miss_tolerance=0.04; // more than these outliers on one side -> enlarge intervall (0.02) REAL shrink_last_intervall=0.15; // heuristic: doubling N decreases fluctuations by ... (0.1) REAL left=0.85; // only the start intervall (for the first N in each dim) REAL right=1.25; // for high N [0.85;1.1]; for beginning with low N [0.4;1.8] // minmax for N=160000 0.96/0.83 to 1.04/1.06 (2dim/6dim) int dimsteps=upperdim-lowerdim+1; minmax* intervall=new minmax[dimsteps+1]; REAL ffc_theo; // set starting values for left & right int i; for (i=0;i<dimsteps+1;i++) { ffc_theo=ff_guessed((NUMBER)lower_N,lowerdim+i, parameter); intervall[i]=minmax(left*ffc_theo, right*ffc_theo); } muvarskewkurt<REAL> ff; minmax mm; NUMBER N; int dim; for (REAL N_=lower_N;N_<=upper_N;N_*=2){ N=(NUMBER)floor(N_); for (dim=lowerdim;dim<upperdim+1;dim++){ mm=intervall[dim-lowerdim]; left=mm.min; right=mm.max; find_mean_ff_with_criterion(criterion, parameter, namecriterion, ff_guessed, N, dim, at_least, tolerance, left, right, miss_tolerance, clusteranalysis_file.c_str(), bestresults_file.c_str(), ff, mm); intervall[dim-lowerdim]=minmax(mm.min+(ff.mu.av()-mm.min)*shrink_last_intervall, mm.max-(mm.max-ff.mu.av())*shrink_last_intervall) ; } } delete[] intervall; }

void find_ffc_frontend (    )

Definition at line 290 of file ff.h. References COUNTER, find_ffc_scanning_N_and_dim(), log(), MAXDIM, MAXNUMBER, NUMBER, REAL, and rounded(). Referenced by main(). { cout<<"Hello!\nThe simulation will take some time."<<endl; cout<<"The higher the wanted dimension, the slower!"<<endl; cout<<"Please type in the range of dimensions you are interested in"<<endl; int lowerdim=1, upperdim=MAXDIM; do{ cout<<"[1..."<<MAXDIM<<", 1..."<<MAXDIM<<"] "; cin >> lowerdim>>upperdim; }while(lowerdim>upperdim || lowerdim<1 || upperdim<1 || lowerdim>MAXDIM ||upperdim>MAXDIM); cout<<"\nThanks.\nNow type in the range of N (number of spheres) you are interested in."<<endl; cout<<"The lower number will be doubled while <= the upper number."<<endl; cout<<"Attention: The algorithm is optimized for these N only:"<<endl; cout<<"312(type in 312.5), 625, 1250, 2500, 5000, 10000, 20000, 40000, 80000, 160000, 320000"; cout<<endl; REAL lower_N=78; NUMBER upper_N=MAXNUMBER; do{ cout<<"[1..."<<MAXNUMBER<<", 1..."<<MAXNUMBER<<"] "; cin >> lower_N>>upper_N; }while (lower_N>upper_N || lower_N<1 || upper_N<1 || lower_N>MAXNUMBER ||upper_N>MAXNUMBER); cout<<"Very good.\nNow...how good shall the result be?"; cout<<"\nPlease type in the target accuracy in %"; REAL tol=5; do{ cout<<"[0.1 ... 50]"; cin >> tol; }while (tol<0.01 || tol>50 ); tol/=100.0; cout<<"OK.\nNow...how many ff-values shall there be AT LEAST for each configuration?"; cout<<"\nPlease type e.g. in 50 for high N, 150 for low N: "; COUNTER at_least=50; do{ cout<<"[0 ... 150] "; cin >> at_least; }while (at_least<1); cout<<"\nOK, now you can switch off the monitor to save energy..."<<endl; COUNTER confs=rounded(log((REAL)upper_N/lower_N)/log(2.0)+1)*(upperdim-lowerdim+1); cout<<"I will simulate these "<<confs<<" configurations and save the results to disk"<<endl; find_ffc_scanning_N_and_dim(lowerdim, upperdim, lower_N, upper_N, tol, at_least); }

void find_ffc_scanning_N_and_dim (  int    lowerdim, int    upperdim, REAL    lower_N, NUMBER    upper_N, REAL    tolerance, COUNTER    at_least )

Definition at line 238 of file ff.h. References COUNTER, datafiles::create_clusteranalysis_resultfile(), datafiles::create_ffc_bestresults_file(), ff_critical_guessed(), FILEHEAD2, find_mean_ffc(), heat_random_generator(), NUMBER, REAL, SEED7, and timestamp_fullyear(). Referenced by find_ffc_frontend(). { srand( SEED7 ); // set the random generator to a seed cout <<endl; heat_random_generator(); cout <<endl; // write File-Intro to bracket-results string clusteranalysis_file=""; clusteranalysis_file=(clusteranalysis_file+FILEHEAD2)+"single-results-" +timestamp_fullyear()+".txt"; create_clusteranalysis_resultfile(clusteranalysis_file.c_str(), "critical"); // write File-Intro to best results string bestresults_file=""; bestresults_file=(bestresults_file+FILEHEAD2)+"best-results-"+timestamp_fullyear()+".txt"; create_ffc_bestresults_file(bestresults_file.c_str()); REAL miss_tolerance=0.04; // more than these outliers on one side -> enlarge intervall (0.02) REAL shrink_last_intervall=0.1; // heuristic: doubling N decreases fluctuations by ... (0.1) REAL left=0.93; // only the start intervall (for the first N in each dim) REAL right=1.03; // for high N [0.85;1.1]; for beginning with low N [0.4;1.8] // minmax for N=160000 0.96/0.83 to 1.04/1.06 (2dim/6dim) int dimsteps=upperdim-lowerdim+1; minmax* intervall=new minmax[dimsteps+1]; REAL ffc_theo; // set starting values for left & right int i; for (i=0;i<dimsteps+1;i++) { ffc_theo=ff_critical_guessed((NUMBER)lower_N,lowerdim+i); intervall[i]=minmax(left*ffc_theo, right*ffc_theo); } muvarskewkurt<REAL> ffc; minmax mm; NUMBER N; int dim; for (REAL N_=lower_N;N_<=upper_N;N_*=2){ N=(NUMBER)floor(N_); for (dim=lowerdim;dim<upperdim+1;dim++){ mm=intervall[dim-lowerdim]; left=mm.min; right=mm.max; find_mean_ffc(N, dim, at_least, tolerance, left, right, miss_tolerance, clusteranalysis_file.c_str(), bestresults_file.c_str(), ffc, mm); intervall[dim-lowerdim]=minmax(mm.min+(ffc.mu.av()-mm.min)*shrink_last_intervall, mm.max-(mm.max-ffc.mu.av())*shrink_last_intervall) ; } } delete[] intervall; }

bool find_mean_ff_with_criterion (  bool(*    criterion)(REAL, arguments1 &), REAL    parameter, string    namecriterion, REAL(*    ff_guessed)(NUMBER, int, REAL), NUMBER    N, int    dim, COUNTER    at_least, REAL    accuracy, REAL    left, REAL    right, REAL    loose_tolerance, const char *    clusteranalysis_file, const char *    bestresults_file, muvarskewkurt< REAL > &    result_ff, minmax &    result_minmax )

Definition at line 368 of file ff.h. References ASCII_PLUSMINUS, measure< REAL >::av(), COUNTER, datafiles::create_ff_file(), FILEHEAD2, find_one_ff_with_criterion(), give_short_timestamp(), GRIDSIZE, increasing_integers(), NUMBER, REAL, measure< REAL >::sdev(), set_dim(), throw_spheres(), datafiles::write_best_ff_line(), datafiles::write_best_ff_outofmemory(), and datafiles::write_ff_line(). Referenced by find_ff_with_criterion_scanning_N_and_dim(). { sphere *spheres = new sphere[N+1]; if (spheres==NULL) { write_best_ff_outofmemory(bestresults_file,N,dim, ("find_"+namecriterion+"(...): sphere *spheres").c_str()); result_minmax=minmax(left,right); return false; } set_dim(spheres,0,N,dim); NUMLIST all; increasing_integers (all, N); cout <<"\nN="<<N<<" dim="<<dim<<" Create the datafile..."<<endl; char buffer[100]; sprintf(buffer, "-%ddim-N%d-M%d-T%1.3f.txt", dim, N, at_least, accuracy); string fn=""; fn=FILEHEAD2+namecriterion+buffer; create_ff_file(fn.c_str(), namecriterion); REAL ff_theo=ff_guessed(N,dim, parameter); REAL tolerance_absolute=accuracy*ff_theo; cout<<"Now I find the "<<namecriterion<<" of single realizations in ("<<left<<", "<<right<<") with "; cout<<ASCII_PLUSMINUS<<tolerance_absolute<<" ("<<tolerance_absolute/ff_theo*100<<"%)"<<endl; cout<<"until the mean is found "<<ASCII_PLUSMINUS<<accuracy*ff_theo; cout<<" ("<<accuracy*100<<"%)\n"<<endl; measuredouble one_ff; std::list<REAL> results; muvarskewkurt<REAL> ff; minmax mm; // use only once! then .reset() ! string throwtime; COUNTER nn=1; COUNTER missedleft=0;COUNTER missedright=0; REAL errorsum=0; string foundtime; clock_t totaltime, brackettime, intervalltime; totaltime=clock(); int missed; REAL new_shot=2.0; // if missed, then double/half that intervall border REAL enlarger=0.05; // too many outliers -> add 5% to intervall border REAL l,r; // temporary left, right until missed==0 REAL dummy=1.0; // for calculate_moments result type do{ // until accurracy of mean sufficient throw_spheres(spheres, all); throwtime=give_short_timestamp(); brackettime=0; l=left; r=right; // the 'theoretical' value (if it is to big) is only used for the first 5 single_ff's if (nn>5) tolerance_absolute=accuracy * minof2<REAL>(ff_theo, ff.mu.av()); do{ // until single realization bracketed (== not missed) missed=find_one_ff_with_criterion(criterion, parameter, l, r, tolerance_absolute, spheres, all, throwtime, clusteranalysis_file, one_ff, intervalltime); brackettime+=intervalltime; if (missed==-1) { cout<<"mL "<<flush; missedleft++; l/=new_shot; // for this realization only if (missedleft/(REAL)nn>loose_tolerance) { left-=left*enlarger; cout<<" eL<<< ("<<left<<", "<<right<<")"<<flush; } } if (missed==+1) { cout<<"mR "<<flush; missedright++; r*=new_shot; // for this realization only if (missedright/(REAL)nn>loose_tolerance) { right+=right*enlarger; cout<<" eR>>> ("<<left<<", "<<right<<")"<<flush; } } if (missed==2) { cout<<"\nError: left bracket > right bracket (Please mail: cpp__at__AndreasKrueger__dot__de)\n"<<endl; exit(2); } } while (missed!=0); mm.set_if_more_extreme(one_ff.av()); errorsum+=one_ff.sdev(); results.push_back(one_ff.av()); ff=calculate_moments<REAL,REAL>(&manipdata<REAL>::linear, (REAL)42, results, dummy); ff.mu.set_sdev(ff.mu.sdev()+errorsum/nn); // add the mean measurement error ff.sdev_of_mean(nn); // this reduces the dev's to ~1/sqrt(nn) foundtime=give_short_timestamp(); write_ff_line(fn.c_str(),N,dim, GRIDSIZE, one_ff, brackettime, nn, missedleft, missedright, ff, foundtime.c_str()); cout<<"\nloop_"<<nn<<" (ml:"<<missedleft<<", mr:"<<missedright<<") mu="; cout<<ff.mu<<"\t (N="<<N<<", dim="<<dim<<")"<<endl<<endl; nn++; }while (nn<=at_least || ff.mu.sdev()>accuracy*ff.mu.av()); totaltime=clock()-totaltime; write_best_ff_line(bestresults_file,N,dim,GRIDSIZE, ff, nn-1, missedleft, missedright, mm.min, mm.max, totaltime, foundtime.c_str()); result_ff=ff; result_minmax=mm; // return-by-reference: ffc and result_minmax return true; }

bool find_mean_ffc (  NUMBER    N, int    dim, COUNTER    at_least, REAL    mean_tolerance, REAL    left, REAL    right, REAL    loose_tolerance, const char *    clusteranalysis_file, const char *    bestresults_file, muvarskewkurt< REAL > &    result_ffc, minmax &    result_minmax )

Definition at line 128 of file ff.h. References ASCII_PLUSMINUS, measure< REAL >::av(), COUNTER, datafiles::create_ffc_file(), ff_critical_guessed(), FILEHEAD2, find_one_ffc(), give_short_timestamp(), GRIDSIZE, increasing_integers(), NUMBER, REAL, measure< REAL >::sdev(), set_dim(), throw_spheres(), datafiles::write_best_ff_line(), datafiles::write_best_ff_outofmemory(), and datafiles::write_ff_line(). Referenced by find_ffc_scanning_N_and_dim(). { sphere *spheres = new sphere[N+1]; if (spheres==NULL) { write_best_ff_outofmemory(bestresults_file,N,dim, "find_ffc(...): sphere *spheres"); result_minmax=minmax(left,right); return false; } set_dim(spheres,0,N,dim); NUMLIST all; increasing_integers (all, N); cout <<"\nN="<<N<<" dim="<<dim<<" Create the datafile..."<<endl; char buffer[100]; sprintf(buffer, "ffc-%ddim-N%d-M%d-T%1.3f.txt", dim, N, at_least, mean_tolerance); string fn=""; fn=fn+FILEHEAD2+buffer; create_ffc_file(fn.c_str()); REAL ffc_theo=ff_critical_guessed(N,dim); REAL tolerance_absolute=mean_tolerance*ffc_theo; cout<<"Now I find the ffc of single realizations in ("<<left<<", "<<right<<") with "; cout<<ASCII_PLUSMINUS<<tolerance_absolute<<" ("<<tolerance_absolute/ffc_theo*100<<"%)"<<endl; cout<<"until the mean is found "<<ASCII_PLUSMINUS<<mean_tolerance*ffc_theo; cout<<" ("<<mean_tolerance*100<<"%)\n"<<endl; measuredouble one_ffc; std::list<REAL> results; muvarskewkurt<REAL> ffc; minmax mm; // use only once! then .reset() ! string throwtime; COUNTER nn=1; COUNTER missedleft=0;COUNTER missedright=0; REAL errorsum=0; string foundtime; clock_t totaltime, brackettime, intervalltime; totaltime=clock(); int missed; REAL new_shot=2.0; // if missed, then double/half that intervall border REAL enlarger=0.05; // too many outliers -> add 5% to intervall border REAL l,r; // temporary left, right until missed==0 REAL dummy=1.0; // for calculate_moments result type do{ // until accurracy of mean sufficient throw_spheres(spheres, all); throwtime=give_short_timestamp(); brackettime=0; l=left; r=right; do{ // until single realization bracketed (= not missed) missed=find_one_ffc(l, r, tolerance_absolute, spheres, all, throwtime, // clusteranalysis_file, one_ffc, intervalltime); brackettime+=intervalltime; if (missed==-1) { cout<<"mL "<<flush; missedleft++; l/=new_shot; // for this realization only if (missedleft/(REAL)nn>loose_tolerance) { left-=left*enlarger; cout<<" eL<<< ("<<left<<", "<<right<<")"<<flush; } } if (missed==+1) { cout<<"mR "<<flush; missedright++; r*=new_shot; // for this realization only if (missedright/(REAL)nn>loose_tolerance) { right+=right*enlarger; cout<<" eR>>> ("<<left<<", "<<right<<")"<<flush; } } if (missed==2) { cout<<"\nError: left bracket > right bracket (Please mail: cpp__at__AndreasKrueger__dot__de)\n"<<endl; exit(2); } } while (missed!=0); mm.set_if_more_extreme(one_ffc.av()); errorsum+=one_ffc.sdev(); results.push_back(one_ffc.av()); ffc=calculate_moments<REAL,REAL>(&manipdata<REAL>::linear, (REAL)42, results, dummy); ffc.mu.set_sdev(ffc.mu.sdev()+errorsum/nn); // add the mean measurement error ffc.sdev_of_mean(nn); // this reduces the dev's to ~1/sqrt(nn) foundtime=give_short_timestamp(); write_ff_line(fn.c_str(),N,dim, GRIDSIZE, one_ffc, brackettime, nn, missedleft, missedright, ffc, foundtime.c_str()); cout<<"\nloop_"<<nn<<" (ml:"<<missedleft<<", mr:"<<missedright<<") mu="; cout<<ffc.mu<<"\t (N="<<N<<", dim="<<dim<<")"<<endl<<endl; nn++; }while (nn<=at_least || ffc.mu.sdev()>mean_tolerance*ffc.mu.av()); totaltime=clock()-totaltime; write_best_ff_line(bestresults_file,N,dim,GRIDSIZE, ffc, nn-1, missedleft, missedright, mm.min, mm.max, totaltime, foundtime.c_str()); result_ffc=ffc; result_minmax=mm; // return-by-reference: ffc and result_minmax return true; }

int find_one_ff_with_criterion (  bool(*    criterion)(REAL, arguments1 &), REAL    parameter, REAL    left, REAL    right, REAL    tol, sphere *    spheres, NUMLIST &    L_sph, string &    throwtime, const char *    clusteranalysis_file, measuredouble &    one_ff, clock_t &    brackettime )

Definition at line 347 of file ff.h. References bracket_ff(), getdim(), NUMBER, and REAL. Referenced by find_mean_ff_with_criterion(). { NUMBER N=L_sph.size(); int dim=getdim(spheres[L_sph.front()]); REAL dummy=42; arguments1 arg(N,dim,spheres, &L_sph, dummy, &throwtime, clusteranalysis_file, parameter); measuredouble ff; brackettime=clock(); int missed=bracket_ff(criterion, arg, left,right, tol, ff); brackettime=clock()-brackettime; if (missed==0) one_ff=ff; else one_ff=0; return missed; }

int find_one_ffc (  REAL    left, REAL    right, REAL    tol, sphere *    spheres, NUMLIST &    L_sph, string &    throwtime, const char *    clusteranalysis_file, measuredouble &    one_ffc, clock_t &    brackettime )

Definition at line 108 of file ff.h. References bracket_ff(), getdim(), is_there_a_spanning_cluster(), NUMBER, and REAL. Referenced by find_mean_ffc(). { NUMBER N=L_sph.size(); int dim=getdim(spheres[L_sph.front()]); REAL dummy=42; arguments1 arg(N,dim,spheres, &L_sph, dummy, &throwtime, clusteranalysis_file, dummy); measuredouble ffc; brackettime=clock(); int missed=bracket_ff(&is_there_a_spanning_cluster, arg, left,right, tol, ffc); brackettime=clock()-brackettime; if (missed==0) one_ffc=ffc; else one_ffc=0; return missed; }

fillingfactor_functions give_one_stepfunction (  int    num )

Definition at line 641 of file ff.h. References ff::fillingfactor_functions::fn, load_stepfunctions(), N_STEPFN, ff::fillingfactor_functions::name, and ff::fillingfactor_functions::theory. Referenced by optimize::test_average_time_for_specified_cuts(). { fillingfactor_functions all_stepfns[N_STEPFN+1]; load_stepfunctions(all_stepfns); fillingfactor_functions stepfn; stepfn.name=all_stepfns[num].name; stepfn.fn=all_stepfns[num].fn; stepfn.theory=all_stepfns[num].theory; return stepfn; }

bool is_the_biggestcluster_bigger_than_a_ratio (  REAL    ff, arguments1 &    arg )

Definition at line 581 of file ff.h. References ff::arguments1::clusteranalysis_file, ff::arguments1::dim, give_radius(), GRIDSIZE, ff::arguments1::L_sph_numbers, ff::arguments1::N, ff::arguments1::parameter, REAL, counters::setR_count_analyze_step(), ff::arguments1::spheres, ff::arguments1::throwtime, and datafiles::write_one_result(). Referenced by load_stepfunctions(). { REAL RaDIuS=give_radius(ff, arg.N, GRIDSIZE, arg.dim); one_result step; clock_t dummy1, dummy2; step= setR_count_analyze_step(arg.N, arg.dim, arg.spheres, *(arg.L_sph_numbers), RaDIuS, *arg.throwtime, dummy1, dummy2); write_one_result(arg.clusteranalysis_file, ff, step, arg.N, arg.dim, GRIDSIZE); return (step.biggest_clsz > arg.N * arg.parameter); }

bool is_the_incl_meancluster_bigger_than_a_ratio (  REAL    ff, arguments1 &    arg )

Definition at line 595 of file ff.h. References ff::arguments1::clusteranalysis_file, ff::arguments1::dim, give_radius(), GRIDSIZE, ff::arguments1::L_sph_numbers, ff::arguments1::N, ff::arguments1::parameter, REAL, counters::setR_count_analyze_step(), ff::arguments1::spheres, ff::arguments1::throwtime, and datafiles::write_one_result(). Referenced by load_stepfunctions(). { REAL RaDIuS=give_radius(ff, arg.N, GRIDSIZE, arg.dim); one_result step; clock_t dummy1, dummy2; step= setR_count_analyze_step(arg.N, arg.dim, arg.spheres, *(arg.L_sph_numbers), RaDIuS, *arg.throwtime, dummy1, dummy2); write_one_result(arg.clusteranalysis_file, ff, step, arg.N, arg.dim, GRIDSIZE); return (step.mean_clsz > arg.N * arg.parameter); }

bool is_the_numberofcl_smaller_than_a_ratio (  REAL    ff, arguments1 &    arg )

Definition at line 560 of file ff.h. References ff::arguments1::clusteranalysis_file, ff::arguments1::dim, give_radius(), GRIDSIZE, ff::arguments1::L_sph_numbers, ff::arguments1::N, ff::arguments1::parameter, REAL, counters::setR_count_analyze_step(), ff::arguments1::spheres, ff::arguments1::throwtime, and datafiles::write_one_result(). Referenced by load_stepfunctions(). { REAL RaDIuS=give_radius(ff, arg.N, GRIDSIZE, arg.dim); one_result step; clock_t dummy1, dummy2; step= setR_count_analyze_step(arg.N, arg.dim, arg.spheres, *(arg.L_sph_numbers), RaDIuS, *arg.throwtime, dummy1, dummy2); write_one_result(arg.clusteranalysis_file, ff, step, arg.N, arg.dim, GRIDSIZE); return (step.numberof_cl < arg.N * arg.parameter); }

bool is_there_a_spanning_cluster (  REAL    ff, arguments1 &    arg )

Definition at line 59 of file ff.h. References ff::arguments1::clusteranalysis_file, ff::arguments1::dim, give_radius(), GRIDSIZE, ff::arguments1::L_sph_numbers, ff::arguments1::N, REAL, counters::setR_count_analyze_step(), ff::arguments1::spheres, ff::arguments1::throwtime, and datafiles::write_one_result(). Referenced by find_one_ffc(), and load_stepfunctions(). { REAL RaDIuS=give_radius(ff, arg.N, GRIDSIZE, arg.dim); one_result step; clock_t dummy1, dummy2; step= setR_count_analyze_step(arg.N, arg.dim, arg.spheres, *(arg.L_sph_numbers), RaDIuS, *arg.throwtime, dummy1, dummy2); write_one_result(arg.clusteranalysis_file, ff, step, arg.N, arg.dim, GRIDSIZE); return step.perc_lr(); }

bool is_there_only_one_cluster (  REAL    ff, arguments1 &    arg )

Definition at line 544 of file ff.h. References ff::arguments1::clusteranalysis_file, ff::arguments1::dim, give_radius(), GRIDSIZE, ff::arguments1::L_sph_numbers, ff::arguments1::N, REAL, counters::setR_count_analyze_step(), ff::arguments1::spheres, ff::arguments1::throwtime, and datafiles::write_one_result(). Referenced by load_stepfunctions(). { REAL RaDIuS=give_radius(ff, arg.N, GRIDSIZE, arg.dim); one_result step; clock_t dummy1, dummy2; step= setR_count_analyze_step(arg.N, arg.dim, arg.spheres, *(arg.L_sph_numbers), RaDIuS, *arg.throwtime, dummy1, dummy2); write_one_result(arg.clusteranalysis_file, ff, step, arg.N, arg.dim, GRIDSIZE); return (step.numberof_cl == 1); }

void load_stepfunctions (  fillingfactor_functions *    stepfn )

Definition at line 619 of file ff.h. References ff_all_in1clst_guessed(), ffbig_guessed(), ffmean1_guessed(), ffnoc_guessed(), ff::fillingfactor_functions::fn, is_the_biggestcluster_bigger_than_a_ratio(), is_the_incl_meancluster_bigger_than_a_ratio(), is_the_numberofcl_smaller_than_a_ratio(), is_there_a_spanning_cluster(), is_there_only_one_cluster(), ff::fillingfactor_functions::name, and ff::fillingfactor_functions::theory. Referenced by find_ff_with_criterion_frontend(), give_one_stepfunction(), and commandline::start_subprg(). { stepfn[1].fn=&is_there_a_spanning_cluster; stepfn[1].name="ffc"; stepfn[1].theory=&ff_critical_guessed; stepfn[2].fn=&is_there_only_one_cluster; stepfn[2].name="ff_allin1clst"; stepfn[2].theory=&ff_all_in1clst_guessed; stepfn[3].fn=&is_the_numberofcl_smaller_than_a_ratio; stepfn[3].name="ff_noc"; stepfn[3].theory=&ffnoc_guessed; stepfn[4].fn=&is_the_biggestcluster_bigger_than_a_ratio; stepfn[4].name="ff_biggest"; stepfn[4].theory=&ffbig_guessed; stepfn[5].fn=&is_the_incl_meancluster_bigger_than_a_ratio; stepfn[5].name="ff_incl-mean"; stepfn[5].theory=&ffmean1_guessed; }

---

Variable Documentation

const int ff::N_STEPFN = 5

Definition at line 617 of file ff.h. Referenced by find_ff_with_criterion_frontend(), and give_one_stepfunction().

Diploma Thesis Sourcecode Documentation check out the text and the executable binaries

www.AndreasKrueger.de/thesis/code