Diploma Thesis Percolation Simulation C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code

                 

---

counters Namespace Reference

Functions
void	neighbour_recursion (sphere *array, NUMBER first, NUMBER last, NUMBER actualsph, NUMBER clnumber)
NUMBER	count_clusters_recursively (sphere *array, NUMBER first, NUMBER last, NUMBER first_clno)
NUMBER	list_to_temp_array_and_find_cluster (sphere *spheres, NUMLIST &sphlist, NUMBER first_clno)
NUMBER	neighbour_naive (sphere *array, NUMBER first, NUMBER last, NUMBER actualsph, NUMBER clnumber)
clock_t	countclusters_naive (sphere *array, NUMBER first, NUMBER last, NUMBER *clustertable)
NUMBER	neighbour_l (sphere *array, NUMLIST &sphlist, NUMLIST::iterator firstsph, NUMLIST::iterator actualsph, NUMBER clnumber)
clock_t	countclusters_l (sphere *array, NUMLIST &sphlist, NUMBER *clustertable, NUMBER &clusternumber)
NUMBER	list_to_given_array_and_find_cluster (sphere *spheres, sphere *copy, NUMLIST &sphlist, NUMBER first_clno)
NUMBER	count_clusters_iteratively (sphere *array, NUMBER first, NUMBER last, NUMBER first_clno)
NUMBER	count_clusters_iteratively2 (sphere *array, NUMBER first, NUMBER last, NUMBER first_clno)
NUMBER	count_clusters_iteratively_only_selected_spherenumbers (sphere *array, std::vector< NUMBER > &sphnumber, NUMBER N, NUMBER first_clno)
clock_t	naive_count_and_analyze (sphere *spheres, NUMBER first, NUMBER last, NUMBER *histo, NUMBER &biggestcl, REAL &averagecl)
NUMBER	naive_arraycount_and_analyze (sphere *spheres, NUMBER first, NUMBER last, NUMBER *histo, NUMBER &biggestcl, REAL &averagecl)
clock_t	sort_naivecount_and_analyze (sphere *spheres, sphere *copy, NUMBER first, NUMBER last, NUMBER *histo, NUMBER &biggestcl, REAL &averagecl)
clock_t	naive_listcount_and_analyze (sphere *spheres, NUMLIST &sphlist, NUMBER N, NUMBER *histo, NUMBER &biggestcl, REAL &averagecl)
clock_t	copy_l_count_and_analyze (sphere *spheres, sphere *copy, NUMLIST &sphlist, NUMBER *histo, NUMBER &biggestcl, REAL &averagecl)
bool	reference_test (NUMBER N, int dim, COUNTER cuts)
one_result	setR_count_analyze_step (NUMBER N, int dim, sphere *spheres, NUMLIST &L_sph_numbers, REAL radius, string &throwtime, clock_t &clcount_time, clock_t &spclsearch_time)
one_result	throw_dnc_count_analyze_step (sphere *spheres, NUMLIST &L_sph_numbers, REAL radius, clock_t &clcount_time, clock_t &spclsearch_time)
void	divide_all_spheres (sphere *array, NUMLIST &original, NUMLIST &lowerlist, NUMLIST &upperlist, COORDFLOAT border, int direction)
NUMBER	combine (sphere *spheres, NUMLIST &sph1, NUMLIST &sph2, cluson *clst, NUMBER firstclno, NUMBER c1, NUMBER c2, COORDFLOAT border, int direction)
NUMBER	divide_once_count_and_combine (sphere *spheres, sphere *temp, NUMLIST &all, cluson *clst, NUMBER firstclno, COORDFLOAT border, int direction)
NUMBER	divide_once_count_and_analyze (sphere *spheres, sphere *temp, NUMLIST &all, NUMBER N, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
NUMBER	divide_two_times_count_and_analyze (sphere *spheres, sphere *temp, NUMLIST &all, NUMBER N, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
NUMBER	divide_three_times_count_and_analyze (sphere *spheres, sphere *temp, NUMLIST &all, NUMBER N, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
COUNTER	maximal_dividings_in_one_coordinate (COORDFLOAT spacelength, REAL radius)
NUMBER	partcount (sphere *spheres, NUMLIST &all, COORDFLOAT l, COORDFLOAT r, COORDFLOAT lm, COORDFLOAT rm, COUNTER divstep, COUNTER divmax, int direction, int dimension, cluson *clusters, NUMBER firstclno)
NUMBER	divide_d_times_count_and_analyze (sphere *spheres, NUMLIST &all, NUMBER N, NUMBER d, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
COUNTER	choose_optimal_cuts (int dim, NUMBER N, REAL R)
void	test_cuts_function ()
NUMBER	dividecount (sphere *spheres, NUMLIST &all, COORDFLOAT l, COORDFLOAT r, COORDFLOAT lm, COORDFLOAT rm, COUNTER divstep, COUNTER divcounter, int direction, int dimension, cluson *clusters, NUMBER firstclno)
NUMBER	count_analyze_and_return_clusters (NUMBER c, sphere *spheres, NUMLIST &all, cluson *clusters, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
NUMBER	divide_by_c_cuts_count_and_analyze (sphere *spheres, NUMLIST &all, NUMBER c, NUMBER *histogram, NUMBER &biggestcl, REAL &averagecl)
NUMBER	divide_count_and_analyze (sphere *spheres, NUMLIST &all, NUMBER c, cluson *clusters, NUMBER &biggestcl, REAL &mean_clsz)

---

Function Documentation

COUNTER choose_optimal_cuts (  int    dim, NUMBER    N, REAL    R )

Definition at line 732 of file divide_and_conquer.h. References choose_optimal_cuts_ffc(), choose_optimal_cuts_ffs(), COUNTER, ff_critical_guessed(), give_radius(), GRIDSIZE, log(), NUMBER, pow(), REAL, rounded(), and saturating_fillingfactor(). Referenced by starters::into_file7_pt1(), starters::into_file8_pt1(), setR_count_analyze_step(), and test_cuts_function(). { REAL rc=give_radius(ff_critical_guessed(N, dim), N, GRIDSIZE, dim); REAL rs=give_radius(saturating_fillingfactor(dim, N), N, GRIDSIZE, dim); // cout <<"rc="<<rc<<" rs="<<rs<<" this R="<<R<<endl; REAL lowest_N=39.0625; NUMBER Nclose=rounded(lowest_N * rounded(pow(2, 1+rounded(log(N/(2*lowest_N))/log(2))))); if (Nclose>480000) Nclose=480000; // cout <<"N="<<N<<" Nclose="<<Nclose<<endl; COUNTER cuts_c=choose_optimal_cuts_ffc(dim, Nclose); COUNTER cuts_s=choose_optimal_cuts_ffs(dim, Nclose); if (cuts_s > cuts_c) cuts_s=cuts_c; if (dim==1) return cuts_c; // because then rs==rc REAL cuts=cuts_c + (cuts_s-cuts_c)* (R-rc)/(rs-rc); // cout <<"cuts_c="<<cuts_c<<" cuts_s="<<cuts_s<<" cuts_R="<<cuts<<" return "<<endl; cuts=rounded(cuts); return (COUNTER)(cuts>0?cuts:0); }

NUMBER combine (  sphere *    spheres, NUMLIST &    sph1, NUMLIST &    sph2, cluson *    clst, NUMBER    firstclno, NUMBER    c1, NUMBER    c2, COORDFLOAT    border, int    direction )

Definition at line 39 of file divide_and_conquer.h. References sphere::c, sphere::clno, clusterneighbours::clusno, COORDFLOAT, analyze::edgespheres(), errorout(), find_biggestradius(), lower(), NUMBER, overlap2(), REAL, set_clusternumber(), cluson::sphlist, and swapcluson(). Referenced by divide_once_count_and_combine(), divide_three_times_count_and_analyze(), divide_two_times_count_and_analyze(), dividecount(), and partcount(). { if (sph1.empty() || sph2.empty()) return c2; // if one of the parts is empty, // do nothing sphere s1=spheres[*sph1.begin()]; sphere s2=spheres[*sph2.begin()]; sphere temp=s1; // for a faster overlap-check if (s1.clno > s2.clno ) { errorout("combine is not possible, \nbecause clusno's in first list greater than in second list"); cout <<s1.clno <<"\t"<< s2.clno<<endl; exit (1); } if (lower(s2.c-s1.c, 0,direction)) { errorout("combine is not possible, \nbecause coordinates of first list are higher than of second list"); cout <<"(in direction "<<direction<<" ): s1.c="<<s1.c<<" s2.c="<<s2.c<<endl; exit(1); } REAL radius1=find_biggestradius(spheres,sph1); REAL radius2=find_biggestradius(spheres,sph2); REAL radius=( (radius1 > radius2) ? radius1 : radius2); NUMLIST e1, e2; edgespheres(spheres, sph1, e1,border, 2*radius, direction); edgespheres(spheres, sph2, e2,border, 2*radius, -direction); // cout <<"number of edgespheres: "<< e1.size()<<"\t"<<e2.size()<<endl; // now find all overlapping edgespheres -> clstoverlap[ ] // = list of directly overlapping clno's (both ways "forwards" and "backwards"!) // !!! one clno might be mentioned several times !!! clusterneighbours *clstoverlap = new clusterneighbours[c2-firstclno]; // for the clusternumbers [firstclno;...c1.............;c2-1] // use the (smaller) array [0;...........c1-firstclno...;c2-firstclno-1] NUMLIST::iterator esph1, esph2; // idea: sort first perpendicular to cutline, // then compare only those within a certain distance // but at the moment, this checks _all_ edgespheres: for (esph1=e1.begin();esph1!=e1.end();esph1++){ for (esph2=e2.begin();esph2!=e2.end();esph2++){ s1= spheres[*esph1]; s2= spheres[*esph2]; if (overlap2 (s1,s2,temp)) { // overlapping spheres -> overlapping clusters clstoverlap[s1.clno-firstclno].clusno.push_back ( s2.clno); // forwards clstoverlap[s2.clno-firstclno].clusno.push_back ( s1.clno); // backwards } } } e1.clear(); e2.clear(); // now follow all cluster-connections in clstoverlap[] // delete the multiple entries // and collect all clno's of overlapping clusters // in the list with the smallest clusternumber NUMLIST::iterator nneighb ; NUMBER clno; for (clno=firstclno;clno<=c1-1;clno++){ NUMLIST &neighbours=clstoverlap[clno-firstclno].clusno; // alias (!) if (! neighbours.empty() ){ // no overlap if ( *(neighbours.begin()) != -1) // already counted { for (nneighb=neighbours.begin();nneighb!=neighbours.end();nneighb++){ while ( (*nneighb==clno) || (*(clstoverlap[*nneighb-firstclno].clusno.begin())==-1 )) { nneighb=neighbours.erase(nneighb); if (nneighb==neighbours.end()) break; } if (nneighb==neighbours.end()) break; neighbours.splice(neighbours.end(), clstoverlap[*nneighb-firstclno].clusno); clstoverlap[*nneighb-firstclno].clusno.push_front(-1); } } else neighbours.clear(); } } /* // the following is not necessary if the tests below are switched off // because the combination is done in [firstclno;c1-1] only // // clear the backwards connections (that were set to -1 in the above process) for (clno=c1;clno<=c2-1;clno++){ NUMLIST &neighbours=clstoverlap[clno-firstclno].clusno; if ( neighbours.size() != 0 && *(neighbours.begin()) == -1 ) { neighbours.clear(); } } // only a test (time-consuming!): // test if all self-references and "-1" have been erased NUMBER s; for (clno=firstclno;clno<=c2-1;clno++){ NUMLIST &neighbours=clstoverlap[clno-firstclno].clusno; if ( neighbours.size()!=0 && (*(neighbours.begin())) == -1) { error("ALARM: -1 left"); cout << "clno="<<clno<<endl; cout << "firstclno="<<firstclno<<" c1="<<c1<<" c2="<<c2<<endl; exit(1); } s=neighbours.size(); neighbours.remove(clno); s=s-neighbours.size(); if (s !=0) { error("still self-references in clusterlist"); cout << " clno="<<clno<<" # of self references=" <<s<<endl; exit(1); } } // only a test (time consuming!) // test if all the clusters have been combined // by looking for non-empty backwards connection lists for (clno = c1 ; clno<= c2-1;clno++){ if (clstoverlap[clno-firstclno].clusno.size()!= 0) { error ("not found every connection during combining"); cout <<"clno="<<clno; cout <<" overlap["<<clno<<"].clusno.size = "<<clstoverlap[clno-firstclno].clusno.size()<<endl; NUMLIST::iterator cl; for (cl=clstoverlap[clno-firstclno].clusno.begin();cl!=clstoverlap[clno-firstclno].clusno.end();cl++){ cout <<*cl<< " "; } cout <<endl; exit(1); } } // show the resulting cluster combination cout <<"\ncombined clusters are"<<endl; for (clno=firstclno;clno<=c1-1;clno++){ NUMLIST &neighbours=clstoverlap[clno-firstclno].clusno; if (! neighbours.empty() ){ cout <<"{"<< clno<<"+ "; for (nneighb=neighbours.begin();nneighb!=neighbours.end();nneighb++){ cout <<*nneighb<< " "<<flush; } cout <<"}\t"<<flush; } } */ // now combine the clusters of spheres according to clstoverlap // and set the right clusternumber to each sphere // idea: perhaps renumbering doesn't have to be done here, but below for (clno=firstclno;clno<=c1-1;clno++){ NUMLIST &neighbours=clstoverlap[clno-firstclno].clusno; if (! neighbours.empty() ){ for (nneighb=neighbours.begin();nneighb!=neighbours.end();nneighb++){ set_clusternumber (spheres, clst[*nneighb].sphlist,clno); clst[clno].sphlist.splice(clst[clno].sphlist.end(), clst[*nneighb].sphlist); } } } delete[] clstoverlap; // clean clustertable of empty clusters // and set the right clno to each sphere NUMBER highest=c2-1; for (clno=firstclno;clno<=c2-1;clno++){ if (! clst[clno].sphlist.empty()) highest=clno; else{ // find first non-empty NUMBER j; for (j=clno+1;j<=c2-1;j++) if (! clst[j].sphlist.empty()) break; if (j==c2) {clno=c2;break;} // the rest is also empty else{ swapcluson(clst[clno],clst[j]); set_clusternumber (spheres, clst[clno].sphlist,clno); if (!clst[j].sphlist.empty()) { errorout ("error in getting rid of empty clusters (after swap)"); cout <<"should be empty: clno j="<<j<<endl; cout <<"was swapped: clno ="<<clno<<endl; exit (1); } highest=clno; } } } c2=highest+1; // first empty clusternumber return (c2); }

clock_t copy_l_count_and_analyze (  sphere *    spheres, sphere *    copy, NUMLIST &    sphlist, NUMBER *    histo, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 133 of file counters.h. References naive_count_and_analyze(), NUMBER, and REAL. Referenced by starters::listcount(), and starters::test_list(). { clock_t time=clock(); NUMLIST::iterator iter; NUMBER index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; copy[index]=spheres[*iter]; } naive_count_and_analyze(copy,1,index,histo,biggestcl,averagecl); index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; spheres[*iter]=copy[index]; } return (clock()-time); }

NUMBER count_analyze_and_return_clusters (  NUMBER    c, sphere *    spheres, NUMLIST &    all, cluson *    clusters, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 910 of file divide_and_conquer.h. References sphere::c, dividecount(), analyze::erasehisto(), errorout(), getdim(), GRIDSIZE, NUMBER, and REAL. Referenced by divide_by_c_cuts_count_and_analyze(). { // if (c>=1) { int dimension=getdim( spheres[*all.begin()].c ); NUMBER nextcluster=dividecount(spheres, all, 0,GRIDSIZE,0,GRIDSIZE, 0, c, dimension,dimension, clusters, 1); erasehisto(histogram,1,all.size()); NUMBER biggestcl_no; NUMBER totalnumber= makehistogram ( clusters, 1,nextcluster-1, histogram, biggestcl_no, biggestcl, averagecl); if (totalnumber != (NUMBER)all.size()) { errorout("not all the spheres are in clusters!"); cout << "number of spheres: N="<<all.size(); cout <<" counted="<<totalnumber<<endl; exit(1); } else ; // cout <<"N="<<all.size()<<" counted="<<totalnumber<<endl; // } // else exit(1); return (nextcluster-1); // returns the number of clusters (M0) }

NUMBER count_clusters_iteratively (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER    first_clno )

Definition at line 212 of file cellcount.h. References sphere::clno, getdim(), NUMBER, and overlap2(). Referenced by optimize::compare_recursion_and_Stoddard_iteration(), and optimize::new_vs_old_algo(). { // the idea to this algorithm can be found in // S.D.Stoddard, J.Comp.Phys 27, 291-293 (1978) // Identifying clusters in computer experiments on systems of particles NUMBER i,j,k; NUMBER N=last-first+1; NUMBER* neighbour=new NUMBER[N]; // afterwards contains a "list" of linked spheres for (i=0;i<N;i++) {neighbour[i]=i;} // initialize link"list" NUMBER ntemp; // used for swapping sphere temp( getdim(array[first].c) ); // used as a temporary distance vector for (i=0; i<N-1; i++) { if (neighbour[i]==i) { j=i; do { for (k=i+1; k<N; k++) { if (neighbour[k]==k){ if (overlap2(array[first+j],array[first+k], temp)){ ntemp=neighbour[j]; neighbour[j]=neighbour[k]; neighbour[k]=ntemp; } } } j=neighbour[j]; } while (j!=i); } } // cout<<"\n"; // for (i=0;i<N;i++){cout<<"[L("<<i<<")="<<neighbour[i]<<"] ";} NUMBER clusternumber=first_clno; for (i=0; i<N; i++){ if (array[first+i].clno==0){ j=i; do { array[first+i].clno=clusternumber; i=neighbour[i]; } while (i!=j); clusternumber++; } } delete[] neighbour; return clusternumber; }

NUMBER count_clusters_iteratively2 (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER    first_clno )

Definition at line 264 of file cellcount.h. References sphere::clno, getdim(), NUMBER, and overlap2(). { // the idea to this algorithm can be found in // S.D.Stoddard, J.Comp.Phys 27, 291-293 (1978) // Identifying clusters in computer experiments on systems of particles NUMBER i,j,k; NUMBER N=last-first+1; NUMBER* neighbour=new NUMBER[N]; // first~ 1 ; last~ last-first+1 for (i=0;i<N;i++) {neighbour[i]=i;} // initialize linklist NUMBER ntemp; // used for swapping sphere temp( getdim(array[first].c) ); // used as a temporary distance vector NUMBER clusternumber=first_clno; for (i=0; i<N-1; i++) { if (neighbour[i]==i) { array[first+i].clno=clusternumber; j=i; do { for (k=i+1; k<N; k++) { if (neighbour[k]==k){ if (overlap2(array[first+j],array[first+k], temp)){ array[first+k].clno=clusternumber; ntemp=neighbour[j]; neighbour[j]=neighbour[k]; neighbour[k]=ntemp; } } } j=neighbour[j]; } while (j!=i); clusternumber++; } } delete [] neighbour; return clusternumber; }

NUMBER count_clusters_iteratively_only_selected_spherenumbers (  sphere *    array, std::vector< NUMBER > &    sphnumber, NUMBER    N, NUMBER    first_clno )

Definition at line 309 of file cellcount.h. References sphere::clno, getdim(), NUMBER, and overlap2(). Referenced by optimize::compare_recursion_and_Stoddard_iteration(), and optimize::new_vs_old_algo(). { // the idea to this algorithm can be found in // S.D.Stoddard, J.Comp.Phys 27, 291-293 (1978) // Identifying clusters in computer experiments on systems of particles NUMBER i,j,k; NUMBER* neighbour=new NUMBER[N+1]; // afterwards contains a "list" of linked spheres for (i=1;i<=N;i++) {neighbour[i]=i;} // initialize link"list" NUMBER ntemp; // used for swapping sphere temp( getdim(array[sphnumber[N]].c) ); // used as a temporary distance vector for (i=1; i<=N-1; i++) { if (neighbour[i]==i) { j=i; do { for (k=i+1; k<=N; k++) { if (neighbour[k]==k){ if (overlap2(array[sphnumber[j]],array[sphnumber[k]], temp)){ ntemp=neighbour[j]; neighbour[j]=neighbour[k]; neighbour[k]=ntemp; } } } j=neighbour[j]; } while (j!=i); } } // cout<<"\n"; // for (i=0;i<N;i++){cout<<"[L("<<i<<")="<<neighbour[i]<<"] ";} NUMBER clusternumber=first_clno; for (i=1; i<=N; i++){ if (array[sphnumber[i]].clno==0){ j=i; do { array[sphnumber[i]].clno=clusternumber; i=neighbour[i]; } while (i!=j); clusternumber++; } } delete[] neighbour; return clusternumber; }

NUMBER count_clusters_recursively (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER    first_clno )

Definition at line 34 of file cellcount.h. References sphere::clno, neighbour_recursion(), and NUMBER. Referenced by list_to_given_array_and_find_cluster(), and list_to_temp_array_and_find_cluster(). { NUMBER clusternumber=first_clno; for (NUMBER k=first; k<=last; k++) { if (array[k].clno==0) { // if yet uncounted neighbour_recursion(array, k,last, k, clusternumber); // the actual counting process clusternumber++; // increase cluster-counter } } return (clusternumber); }

clock_t countclusters_l (  sphere *    array, NUMLIST &    sphlist, NUMBER *    clustertable, NUMBER &    clusternumber )

Definition at line 164 of file cellcount.h. References neighbour_l(), and NUMBER. Referenced by naive_listcount_and_analyze(). { clock_t start=clock(); NUMBER size; NUMLIST::iterator k; for (k = sphlist.begin(); k != sphlist.end(); k++){ // search for neighbours from each sphere if (array[*k].clno==0) { // if yet uncounted size=neighbour_l(array,sphlist, k, k, clusternumber); // the actual counting process clustertable[clusternumber]=size; // store size to table of all clusters clusternumber++; // increase cluster-counter } } clustertable[clusternumber]=0; // mark the end in that table by: "last cluster is of size 0" return (clock()-start); // return the time (and the clustertable and the next clusternumber!) }

clock_t countclusters_naive (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER *    clustertable )

Definition at line 106 of file cellcount.h. References sphere::clno, neighbour_naive(), and NUMBER. Referenced by naive_arraycount_and_analyze(), and naive_count_and_analyze(). { clock_t start=clock(); NUMBER size; NUMBER clusternumber=0; // start with # 1 for (NUMBER k=first; k<=last; k++) { if (array[k].clno==0) { // if yet uncounted clusternumber++; // increase cluster-counter size=neighbour_naive(array, k,last, k, clusternumber); // the actual counting process clustertable[clusternumber]=size; // store size to table of all clusters } } clustertable[clusternumber+1]=0; // mark the end in that table by: "last cluster is of size 0" return (clock()-start); }

void divide_all_spheres (  sphere *    array, NUMLIST &    original, NUMLIST &    lowerlist, NUMLIST &    upperlist, COORDFLOAT    border, int    direction )

Definition at line 19 of file divide_and_conquer.h. References COORDFLOAT, and lower(). Referenced by divide_once_count_and_combine(), divide_three_times_count_and_analyze(), divide_two_times_count_and_analyze(), dividecount(), partcount(), and starters::test_list(). { NUMLIST::iterator iter1; for (iter1 = original.begin(); iter1 != original.end(); ++iter1){ if ( lower(array[*iter1].c, border, direction)) lowerlist.insert(lowerlist.end(), *iter1); else upperlist.insert(upperlist.end(), *iter1); } }

NUMBER divide_by_c_cuts_count_and_analyze (  sphere *    spheres, NUMLIST &    all, NUMBER    c, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 951 of file divide_and_conquer.h. References count_analyze_and_return_clusters(), NUMBER, and REAL. Referenced by optimize::choose_cuts_with_reference_algo(), optimize::double_N_and_run_all_faster_cuts(), optimize::double_N_and_run_specified_cuts(), starters::into_file7_pt1(), reference_test(), optimize::run_different_cuts(), optimize::test_average_time_for_specified_cuts(), starters::test_occuring_clusternumbers(), test_occuring_clusternumbers(), and test_spanningclusters(). { cluson *clusters=new cluson[all.size()+1]; NUMBER number_of_clusters= count_analyze_and_return_clusters(c, spheres, all, clusters, histogram, biggestcl, averagecl); delete[] clusters; return number_of_clusters; }

NUMBER divide_count_and_analyze (  sphere *    spheres, NUMLIST &    all, NUMBER    c, cluson *    clusters, NUMBER &    biggestcl, REAL &    mean_clsz )

Definition at line 975 of file divide_and_conquer.h. References sphere::c, COORDFLOAT, dividecount(), analyze::erasehisto(), errorout(), exit_out_of_memory(), getdim(), GRIDSIZE, NUMBER, REAL, and waitanykey(). Referenced by setR_count_analyze_step(). { NUMBER *histogram=new NUMBER[all.size()+1]; if (histogram==NULL) exit_out_of_memory("divide_count_and_analyze(...): NUMBER *histogram"); erasehisto(histogram,1,all.size()); int dimension=getdim( spheres[*all.begin()].c ); NUMBER numberof_cl=dividecount(spheres, all, 0,GRIDSIZE,(COORDFLOAT)0,GRIDSIZE, 0, c, dimension,dimension, clusters, 1); NUMBER biggestcl_no; NUMBER totalnumber= makehistogram ( clusters, 1,numberof_cl-1, histogram, biggestcl_no, biggestcl, mean_clsz); if (totalnumber != (NUMBER)all.size()) { errorout("not all the spheres are in clusters!"); cout << "number of spheres: N="<<all.size(); cout <<" counted="<<totalnumber<<endl; waitanykey(); } delete[] histogram; return numberof_cl-1; }

NUMBER divide_d_times_count_and_analyze (  sphere *    spheres, NUMLIST &    all, NUMBER    N, NUMBER    d, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 708 of file divide_and_conquer.h. References analyze::analyze_clusters(), sphere::c, COORDFLOAT, getdim(), GRIDSIZE, NUMBER, partcount(), and REAL. Referenced by optimize::choose_dividings(). { cluson *clusters=new cluson[N+1]; int dimension=getdim( spheres[*all.begin()].c ); NUMBER nextcluster=partcount(spheres, all, 0, GRIDSIZE, (COORDFLOAT)0, GRIDSIZE, 1, d, 1,dimension, clusters, 1); NUMBER biggestcl_no=analyze_clusters (clusters, 1, nextcluster-1,histogram,N,biggestcl,averagecl); delete[] clusters; return (biggestcl_no); }

NUMBER divide_once_count_and_analyze (  sphere *    spheres, sphere *    temp, NUMLIST &    all, NUMBER    N, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 516 of file divide_and_conquer.h. References analyze::analyze_clusters(), divide_once_count_and_combine(), GRIDSIZE, NUMBER, and REAL. Referenced by optimize::new_vs_old_algo(). { cluson *clusters=new cluson[N+1]; NUMBER nextclno; nextclno=divide_once_count_and_combine (spheres, temp, all, clusters,1,GRIDSIZE/2, 1); cout <<" -> combined to: "<<nextclno-1<<" clusters"<<endl; NUMBER biggestcl_no=analyze_clusters (clusters, 1, nextclno-1,histogram,N,biggestcl,averagecl); delete[] clusters; return (biggestcl_no); }

NUMBER divide_once_count_and_combine (  sphere *    spheres, sphere *    temp, NUMLIST &    all, cluson *    clst, NUMBER    firstclno, COORDFLOAT    border, int    direction )

Definition at line 491 of file divide_and_conquer.h. References combine(), COORDFLOAT, divide_all_spheres(), list_to_given_array_and_find_cluster(), make_clusterlist_array(), and NUMBER. Referenced by divide_once_count_and_analyze(), divide_three_times_count_and_analyze(), and divide_two_times_count_and_analyze(). { NUMBER c1,c2; NUMLIST sph1,sph2; divide_all_spheres(spheres, all, sph1,sph2,border,direction); c1=list_to_given_array_and_find_cluster(spheres, temp, sph1, firstclno); c2=list_to_given_array_and_find_cluster(spheres, temp, sph2, c1); cout <<"found "<<c1-firstclno<<" and "<<c2-c1<<" clusters "; cout <<"(c1="<<c1<<", c2="<<c2<<")"; make_clusterlist_array (spheres, all, clst); c2=combine(spheres,sph1,sph2,clst,firstclno,c1,c2,border,direction); return (c2); }

NUMBER divide_three_times_count_and_analyze (  sphere *    spheres, sphere *    temp, NUMLIST &    all, NUMBER    N, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 577 of file divide_and_conquer.h. References analyze::analyze_clusters(), combine(), COORDFLOAT, divide_all_spheres(), divide_once_count_and_combine(), GRIDSIZE, NUMBER, and REAL. { cluson *clusters=new cluson[N+1]; NUMBER nextclno1, nextclno2; NUMBER cl1, cl2; NUMLIST sph1,sph2,sph3,sph4,sph5,sph6; COORDFLOAT border1=GRIDSIZE/2; COORDFLOAT border2=GRIDSIZE/4; divide_all_spheres(spheres, all, sph1,sph2,border1,1); divide_all_spheres(spheres, sph1,sph3,sph4,border1,2); nextclno1=divide_once_count_and_combine (spheres, temp, sph3, clusters,1,border1-border2, 1); cout<<endl; nextclno2=divide_once_count_and_combine (spheres, temp, sph4, clusters,nextclno1,border1-border2, 1); cout<<endl; cl1=combine (spheres,sph3,sph4,clusters,1,nextclno1,nextclno2,border1,2); cout <<" -> combined to: "<<cl1-1<<" clusters"<<endl; divide_all_spheres(spheres, sph2,sph5,sph6,border1,2); nextclno1=divide_once_count_and_combine (spheres, temp, sph5, clusters,cl1,border1+border2, 1); cout <<endl; nextclno2=divide_once_count_and_combine (spheres, temp, sph6, clusters,nextclno1,border1+border2, 1); cout<<endl; cl2=combine (spheres,sph5,sph6,clusters,cl1,nextclno1,nextclno2,border1,2); cout <<" -> combined to: "<<cl2-cl1<<" clusters"<<endl; cout <<"Now these two combined to: "; cl2=combine(spheres,sph1,sph2,clusters,1,cl1,cl2,border1,1); cout<<cl2-1<<" clusters"<<endl; NUMBER biggestcl_no=analyze_clusters (clusters, 1, cl2-1,histogram,N,biggestcl,averagecl); delete[] clusters; return (biggestcl_no); }

NUMBER divide_two_times_count_and_analyze (  sphere *    spheres, sphere *    temp, NUMLIST &    all, NUMBER    N, NUMBER *    histogram, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 539 of file divide_and_conquer.h. References analyze::analyze_clusters(), combine(), COORDFLOAT, divide_all_spheres(), divide_once_count_and_combine(), GRIDSIZE, NUMBER, and REAL. Referenced by optimize::choose_dividings(), and optimize::new_vs_old_algo(). { cluson *clusters=new cluson[N+1]; NUMBER nextclno1, nextclno2; NUMBER cl2; NUMLIST sph1,sph2; COORDFLOAT border1=GRIDSIZE/2; divide_all_spheres(spheres, all,sph1,sph2, border1,1); //cout <<"A) count clusters in left part..."<<endl; nextclno1=divide_once_count_and_combine (spheres, temp, sph1, clusters,1,border1, 2); cout <<" -> combined to: "<<nextclno1-1<<" clusters"<<endl; //cout <<"B) count clusters in right part..."<<endl; nextclno2=divide_once_count_and_combine (spheres, temp, sph2, clusters,nextclno1,border1, 2); cout <<" -> combined to: "<<nextclno2-nextclno1<<" clusters"<<endl; cout <<"Now combine the two results..."; cl2=combine (spheres,sph1,sph2,clusters,1,nextclno1,nextclno2,border1,1); cout <<" -> combined to: "<<cl2-1<<" clusters"<<endl; NUMBER biggestcl_no=analyze_clusters (clusters, 1, cl2-1,histogram,N,biggestcl,averagecl); delete[] clusters; return (biggestcl_no); }

NUMBER dividecount (  sphere *    spheres, NUMLIST &    all, COORDFLOAT    l, COORDFLOAT    r, COORDFLOAT    lm, COORDFLOAT    rm, COUNTER    divstep, COUNTER    divcounter, int    direction, int    dimension, cluson *    clusters, NUMBER    firstclno )

Definition at line 786 of file divide_and_conquer.h. References combine(), COORDFLOAT, COUNTER, divide_all_spheres(), list_to_temp_array_and_find_cluster(), make_clusterlist_array(), and NUMBER. Referenced by count_analyze_and_return_clusters(), divide_count_and_analyze(), and optimize::new_vs_old_algo(). { NUMBER nextclno; if (divstep < divcounter/direction ) { NUMLIST s1, s2; NUMBER ncl1, ncl2; divide_all_spheres (spheres, all, s1,s2,(l+r)/2,direction); ncl1=dividecount(spheres, s1, // RECURSION! l,(l+r)/2, lm,rm, divstep+1, divcounter, direction,dimension, clusters, firstclno); ncl2=dividecount(spheres, s2, // RECURSION! (l+r)/2,r, lm,rm, divstep+1, divcounter, direction,dimension, clusters, ncl1); nextclno=combine(spheres, s1,s2,clusters,firstclno,ncl1,ncl2,(l+r)/2,direction); } else { if (direction==1) { // the core clusterCounter // (naive recursion or iteration with full network) nextclno=list_to_temp_array_and_find_cluster(spheres, all, firstclno); make_clusterlist_array (spheres, all, clusters); } else { // continue in next-lower direction (divcounter-divstep cuts left to do) nextclno=dividecount(spheres, all, lm,rm, lm,rm, 0, divcounter-divstep, direction-1,dimension, clusters, firstclno); } } return nextclno; }

NUMBER list_to_given_array_and_find_cluster (  sphere *    spheres, sphere *    copy, NUMLIST &    sphlist, NUMBER    first_clno )

Definition at line 189 of file cellcount.h. References count_clusters_recursively(), and NUMBER. Referenced by divide_once_count_and_combine(). { NUMLIST::iterator iter; NUMBER index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; copy[index]=spheres[*iter]; } NUMBER first_free_clusternumber=count_clusters_recursively(copy,1,index,first_clno); index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; spheres[*iter]=copy[index]; } return (first_free_clusternumber); }

NUMBER list_to_temp_array_and_find_cluster (  sphere *    spheres, NUMLIST &    sphlist, NUMBER    first_clno )

Definition at line 50 of file cellcount.h. References count_clusters_recursively(), and NUMBER. Referenced by dividecount(), and partcount(). { sphere *copy= new sphere[sphlist.size()+1]; NUMLIST::iterator iter; NUMBER index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; copy[index]=spheres[*iter]; } NUMBER first_free_clusternumber=count_clusters_recursively(copy,1,index,first_clno); index=0; for (iter = sphlist.begin(); iter != sphlist.end(); iter++){ index++; spheres[*iter]=copy[index]; } delete[] copy; return (first_free_clusternumber); }

COUNTER maximal_dividings_in_one_coordinate (  COORDFLOAT    spacelength, REAL    radius )

Definition at line 635 of file divide_and_conquer.h. References COORDFLOAT, COUNTER, log(), and REAL. Referenced by optimize::choose_cuts_with_reference_algo(), optimize::choose_dividings(), optimize::double_N_and_run_all_faster_cuts(), optimize::double_N_and_run_specified_cuts(), and optimize::run_different_cuts(). { REAL boxlength=2*radius; REAL maximal_boxes_in_one_direction=spacelength/boxlength; REAL maximal_dividings=log(maximal_boxes_in_one_direction) / log (2); return ( (int) maximal_dividings ); }

NUMBER naive_arraycount_and_analyze (  sphere *    spheres, NUMBER    first, NUMBER    last, NUMBER *    histo, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 51 of file counters.h. References countclusters_naive(), analyze::erasehisto(), NUMBER, REAL, and set_clustersize_to_each_sphere(). Referenced by optimize::choose_cuts_with_reference_algo(), optimize::choose_dividings(), optimize::compare_recursion_and_Stoddard_iteration(), optimize::double_N_and_run_all_faster_cuts(), optimize::new_vs_old_algo(), and optimize::run_different_cuts(). { NUMBER *tableofclusters=new NUMBER[(last-first+3)]; // must be one bigger than number of spheres because of ending 0 countclusters_naive(spheres, first, last, tableofclusters); //count clusters, vs.1 averagecl=set_clustersize_to_each_sphere(tableofclusters, spheres, first,last); erasehisto(histo,first, last); NUMBER biggestcl_no; makehistogram(tableofclusters,histo,biggestcl,biggestcl_no); delete[] tableofclusters; return (biggestcl_no); }

clock_t naive_count_and_analyze (  sphere *    spheres, NUMBER    first, NUMBER    last, NUMBER *    histo, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 20 of file counters.h. References countclusters_naive(), analyze::erasehisto(), NUMBER, REAL, and set_clustersize_to_each_sphere(). Referenced by copy_l_count_and_analyze(), starters::listcount(), and sort_naivecount_and_analyze(). { // returns these results: // the biggest cluster is of size: << biggestcl // each sphere is on average part of a cluster of size << averagecl // the detailed size-distribution is in << histo[...] clock_t time=clock(); NUMBER *tableofclusters=new NUMBER[(last-first+3)]; // must be one bigger than number of spheres because of ending 0 countclusters_naive(spheres, first, last, tableofclusters); //count clusters, vs.1 averagecl=set_clustersize_to_each_sphere(tableofclusters, spheres, first,last); erasehisto(histo,first, last); NUMBER biggestcl_no; makehistogram(tableofclusters,histo,biggestcl,biggestcl_no); delete[] tableofclusters; return (clock()-time); }

clock_t naive_listcount_and_analyze (  sphere *    spheres, NUMLIST &    sphlist, NUMBER    N, NUMBER *    histo, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 104 of file counters.h. References countclusters_l(), analyze::erasehisto(), NUMBER, REAL, and set_clustersize_to_each_sphere_l(). Referenced by starters::listcount(), and starters::test_list(). { // returns these results: // the biggest cluster is of size: << biggestcl // each sphere is on average part of a cluster of size << averagecl // the detailed size-distribution is in << histo[...] clock_t time=clock(); NUMBER *tableofclusters=new NUMBER[(sphlist.size()+2)]; // must be one bigger than number of spheres because of ending 0 NUMBER clusternumber=1; // first cluster is "1" countclusters_l(spheres,sphlist, tableofclusters, clusternumber); averagecl=set_clustersize_to_each_sphere_l(tableofclusters, spheres, sphlist); erasehisto(histo,1, N); NUMBER biggestcl_no; makehistogram(tableofclusters,histo,biggestcl, biggestcl_no); delete[] tableofclusters; return (clock()-time); }

NUMBER neighbour_l (  sphere *    array, NUMLIST &    sphlist, NUMLIST::iterator    firstsph, NUMLIST::iterator    actualsph, NUMBER    clnumber )

Definition at line 129 of file cellcount.h. References sphere::c, sphere::clno, distance(), getdim(), length(), NUMBER, and sphere::r. Referenced by countclusters_l(). { array[*actualsph].clno=clnumber; // this sphere is set to be found in this cluster myVector distance(getdim(array[*actualsph].c)); bool overlapped; NUMBER size=1; NUMLIST::iterator nextsph; for (nextsph = firstsph; nextsph != sphlist.end(); nextsph++){ if ( array[*nextsph].clno==0 ) { //if ( overlap2(array[*actualsph],array[*nextsph]) ) { // the following 4 lines do the same, but are faster than that: // because of not using operator-(vect1, vect2) which needs a myVector temp; distance=(array[*nextsph].c); distance-=(array[*actualsph].c); overlapped=length(distance) < (array[*actualsph].r + array[*nextsph].r) ; if (overlapped) { size+=neighbour_l (array, sphlist, firstsph, nextsph, clnumber); // recursion, now with nextsph } } } return size; }

NUMBER neighbour_naive (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER    actualsph, NUMBER    clnumber )

Definition at line 78 of file cellcount.h. References sphere::c, sphere::clno, distance(), getdim(), length(), NUMBER, and sphere::r. Referenced by countclusters_naive(). { array[actualsph].clno=clnumber; myVector distance(getdim(array[actualsph].c)); bool overlapped; NUMBER size=1; for (NUMBER nextsph=first;nextsph<=last;nextsph++) { if ( array[nextsph].clno==0 ) { // if ( overlap(array[actualsph],array[nextsph]) ) { // the following 3 lines are faster: // because of not using operator-(vect1, vect2) which needs a vector temp; distance=(array[nextsph].c); distance-=(array[actualsph].c); // using -= instead of - is much faster (no vector temp) overlapped=length(distance) < (array[actualsph].r + array[nextsph].r) ; if (overlapped) { size+=neighbour_naive (array, first, last, nextsph, clnumber); // RECURSION! } } } return size; }

void neighbour_recursion (  sphere *    array, NUMBER    first, NUMBER    last, NUMBER    actualsph, NUMBER    clnumber )

Definition at line 14 of file cellcount.h. References sphere::clno, getdim(), NUMBER, and overlap2(). Referenced by count_clusters_recursively(). { array[actualsph].clno=clnumber; // set this sphere as "counted" by assigning clusternumber sphere temp( getdim(array[actualsph].c) ); // used as a temporary distance vector for (NUMBER nextsph=first;nextsph<=last;nextsph++) { if ( array[nextsph].clno==0 ) { if ( overlap2(array[actualsph],array[nextsph], temp) ) { // this overlap-function uses a temp-sphere-coordinatevector // for storing the difference of the two vectors // (it is much faster than creating one temporary vector // for each overlap-test by using overlap (sphere, sphere) ) neighbour_recursion (array, first, last, nextsph, clnumber); } } } }

NUMBER partcount (  sphere *    spheres, NUMLIST &    all, COORDFLOAT    l, COORDFLOAT    r, COORDFLOAT    lm, COORDFLOAT    rm, COUNTER    divstep, COUNTER    divmax, int    direction, int    dimension, cluson *    clusters, NUMBER    firstclno )

Definition at line 642 of file divide_and_conquer.h. References combine(), COORDFLOAT, COUNTER, divide_all_spheres(), list_to_temp_array_and_find_cluster(), make_clusterlist_array(), and NUMBER. Referenced by divide_d_times_count_and_analyze(). { NUMBER nextclno; if (divmax==0) { nextclno=list_to_temp_array_and_find_cluster(spheres, all, firstclno); make_clusterlist_array (spheres, all, clusters); return nextclno; } if ( direction==dimension ) { if ( divstep==divmax ) { NUMLIST s1, s2; NUMBER ncl1, ncl2; divide_all_spheres (spheres, all, s1,s2,(l+r)/2,direction); //cout <<"\ndir="<<direction<<"\tborders l,r=\t"<<l<<"\t"<<r; //cout <<"\t# of spheres="<<s1.size()<<" and "<<s2.size()<<endl; ncl1=list_to_temp_array_and_find_cluster(spheres, s1, firstclno); ncl2=list_to_temp_array_and_find_cluster(spheres, s2, ncl1); make_clusterlist_array (spheres, all, clusters); nextclno=combine(spheres, s1,s2,clusters,firstclno,ncl1,ncl2,(l+r)/2,direction); } else { NUMLIST s1, s2; NUMBER ncl1, ncl2; divide_all_spheres (spheres, all, s1,s2,(l+r)/2,direction); //cout <<"diV "; ncl1=partcount(spheres, s1, l,(l+r)/2, lm,rm, divstep+1, divmax, direction,dimension, clusters, firstclno); ncl2=partcount(spheres, s2, (l+r)/2,r, lm,rm, divstep+1, divmax, direction,dimension, clusters, ncl1); nextclno=combine(spheres, s1,s2,clusters,firstclno,ncl1,ncl2,(l+r)/2,direction); } } else { if (divstep <= divmax) { NUMLIST s1, s2; NUMBER ncl1, ncl2; divide_all_spheres (spheres, all, s1,s2,(l+r)/2,direction); //cout <<"diV "; ncl1=partcount(spheres, s1, l,(l+r)/2, lm,rm, divstep+1, divmax, direction,dimension, clusters, firstclno); ncl2=partcount(spheres, s2, (l+r)/2,r, lm,rm, divstep+1, divmax, direction,dimension, clusters, ncl1); nextclno=combine(spheres, s1,s2,clusters,firstclno,ncl1,ncl2,(l+r)/2,direction); } else { //cout <<"diM "; nextclno=partcount(spheres, all, lm,rm, lm,rm, 1, divmax, direction+1,dimension, clusters, firstclno); } } return nextclno; }

bool reference_test (  NUMBER    N, int    dim, COUNTER    cuts )

Definition at line 164 of file counters.h. References COUNTER, divide_by_c_cuts_count_and_analyze(), errorout(), GRIDSIZE, increasing_integers(), ms(), NUMBER, R_critical(), R_critical_guessed(), REAL, analyze::sameresult(), set_clusternumber(), set_dim(), set_radius(), sort_naivecount_and_analyze(), and throw_spheres(). { // test if new and old algo's results are the SAME! sphere *scatter = new sphere[N+1]; set_dim(scatter,0,N,dim); throw_spheres(scatter, 1, N); // randomly throw spheres from 1 to N in array scatter REAL r=R_critical(N,GRIDSIZE,dim); if (r==-1) r=R_critical_guessed(N,GRIDSIZE,dim); // with _critical_ sphere radius, if known, otherwise r=guess set_radius(scatter, 1,N,r); // new algo NUMBER *histogram=new NUMBER[(N+1)]; NUMBER biggestcl; REAL averagecl; NUMLIST all; increasing_integers (all, N); // fill the list "all" with the numbers of all spheres clock_t speed=clock(); cout <<"\ndivide_by_c_cuts count (new algo):.."<<flush; set_clusternumber(scatter,1,N,0); // no sphere is found yet divide_by_c_cuts_count_and_analyze(scatter, all, cuts,histogram, biggestcl, averagecl); cout <<" speed: "<<ms(clock()-speed)<<" ms"<<endl; cout <<" (biggestcluster: "<<biggestcl<<"\taverage cluster: "<<averagecl<<" )"<<endl; // old algo sphere *copy = new sphere[N+1]; set_dim(copy,0,N,dim); NUMBER *histogramcontrol=new NUMBER[(N+1)]; speed=clock(); cout <<"\nsorted-array-count (old, naive algo):.. "<<flush; set_clusternumber(scatter,1,N,0); // no sphere is found yet sort_naivecount_and_analyze(scatter, copy, 1, N, histogramcontrol, biggestcl, averagecl); cout <<" speed: "<<ms(clock()-speed)<<" ms"<<endl; cout <<" (biggestcluster: "<<biggestcl<<"\taverage cluster: "<<averagecl<<" )"<<endl; if (sameresult(histogram,histogramcontrol,1,biggestcl)) { cout <<"\nThe new algorithm was tested. Results are perfect. Let us begin.\n\n"<<endl; delete [] scatter, copy, histogram, histogramcontrol; all.clear(); return true; } else { cout <<".\nTERRIBLE !\n"; errorout("The new algorithm has different results. \nPlease write to cpp__at__AndreasKrueger__dot__de\n"); cout<<"cuts="<<cuts<<endl; delete [] scatter, copy, histogram, histogramcontrol; all.clear(); return false; } }

one_result setR_count_analyze_step (  NUMBER    N, int    dim, sphere *    spheres, NUMLIST &    L_sph_numbers, REAL    radius, string &    throwtime, clock_t &    clcount_time, clock_t &    spclsearch_time )

Definition at line 220 of file counters.h. References choose_optimal_cuts(), COUNTER, divide_count_and_analyze(), exit_out_of_memory(), give_short_timestamp(), GRIDSIZE, LONGBITS, analyze::mean_without_lr_spanningcls(), NUMBER, REAL, set_clusternumber(), set_radius(), and spanning_dirs_and_clusters(). Referenced by ff::is_the_biggestcluster_bigger_than_a_ratio(), ff::is_the_incl_meancluster_bigger_than_a_ratio(), ff::is_the_numberofcl_smaller_than_a_ratio(), ff::is_there_a_spanning_cluster(), ff::is_there_only_one_cluster(), and throw_dnc_count_analyze_step(). { COUNTER cuts=choose_optimal_cuts(dim,N, radius); cluson *clusters=new cluson[N+1]; if (clusters==NULL) exit_out_of_memory("radiusstep(...): cluson *clusters"); NUMBER numberof_cl; NUMBER biggestcl; REAL mean_clsz; REAL mean_clsz_without_spcls; LONGBITS spcl_dirs; NUMLIST L_spanningclusters; L_spanningclusters.clear(); clock_t time_start=clock(); set_radius(spheres, 1,N,radius); set_clusternumber(spheres,1,N,0); numberof_cl=divide_count_and_analyze(spheres, L_sph_numbers, cuts, clusters, biggestcl, mean_clsz); clcount_time=(clock()-time_start); clock_t time_spsearch_start=clock(); spcl_dirs=spanning_dirs_and_clusters(spheres, L_sph_numbers, 0, GRIDSIZE, radius, dim, clusters, L_spanningclusters); mean_clsz_without_spcls= mean_without_lr_spanningcls(mean_clsz, N, clusters, L_spanningclusters, spcl_dirs); spclsearch_time=(clock()-time_spsearch_start); string counttime=give_short_timestamp(); delete[] clusters; return one_result(spcl_dirs, numberof_cl, biggestcl, mean_clsz, mean_clsz_without_spcls, clcount_time + spclsearch_time, throwtime, counttime); }

clock_t sort_naivecount_and_analyze (  sphere *    spheres, sphere *    copy, NUMBER    first, NUMBER    last, NUMBER *    histo, NUMBER &    biggestcl, REAL &    averagecl )

Definition at line 74 of file counters.h. References copy_array(), naive_count_and_analyze(), NUMBER, quicksort1(), and REAL. Referenced by starters::into_file(), starters::into_file2(), starters::into_screen(), and reference_test(). { // returns these results: // the biggest cluster is of size: << biggestcl // each sphere is on average part of a cluster of size << averagecl // the most frequent cluster is of size: << mostfreqcl // the detailed size-distribution is in << histo[...] clock_t time=clock(); copy_array(spheres,copy,1,last); // store it before sorting quicksort1 (spheres,1,last); // sort by length naive_count_and_analyze(spheres, first, last, histo, biggestcl, averagecl); copy_array(copy,spheres,1,last); // copy it back return (clock()-time); }

void test_cuts_function (    )

Definition at line 755 of file divide_and_conquer.h. References choose_optimal_cuts(), COUNTER, and REAL. { cout<<"type in dim, N"<<endl; int dim; COUNTER N; cin>>dim>>N; REAL R=0; while (R!=-1){ cout <<"\ntype in R (-1 for end)"; cin>>R; cout <<choose_optimal_cuts(dim, N, R); } }

one_result throw_dnc_count_analyze_step (  sphere *    spheres, NUMLIST &    L_sph_numbers, REAL    radius, clock_t &    clcount_time, clock_t &    spclsearch_time )

Definition at line 253 of file counters.h. References getdim(), give_short_timestamp(), NUMBER, REAL, setR_count_analyze_step(), and throw_spheres(). Referenced by starters::into_file8_pt1(). { NUMBER N=L_sph_numbers.size(); int dim=getdim(spheres[L_sph_numbers.front()]); throw_spheres(spheres, 1, N); string throwtime=give_short_timestamp(); return setR_count_analyze_step(N,dim, spheres, L_sph_numbers, radius, throwtime, clcount_time, spclsearch_time); }

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

www.AndreasKrueger.de/thesis/code