Diploma Thesis Percolation Simulation C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code

                 

---

results.h

Go to the documentation of this file.

// results.h
//
// last change: 22.12.2000
//

namespace results {
        using namespace statistics;


class one_result {
public:
        LONGBITS spcl_dirs;
        NUMBER   numberof_cl;
        NUMBER   biggest_clsz;
        REAL     mean_clsz;
        REAL     mean_clsz2;
        clock_t  last_counttime;
        string   throwtime;
        string   counttime;

        one_result(){};
        one_result(LONGBITS     SPCL_DIR, NUMBER NUMBEROF_CL, 
                           NUMBER BIGGEST_CLSZ, REAL MEAN_CLSZ,REAL MEAN_CLSZ2,
                           clock_t LAST_COUNTTIME, 
                           string& THROWTIME, string& COUNTTIME);
        bool percolate(int direction);
        bool percolate();
        bool perc_lr();
        bool perc_tb();
        bool perc_all_dirs(int dim);

//      friend void my_fprintf(FILE* outFile, one_result last, NUMBER N, int dim, COORDFLOAT L);
//      friend void my_fprintf_nothing(FILE* outFile);

};

one_result::one_result(LONGBITS SPCL_DIRS, 
                                           NUMBER       NUMBEROF_CL, 
                                           NUMBER       BIGGEST_CLSZ, 
                                           REAL         MEAN_CLSZ,
                                           REAL         MEAN_CLSZ2,
                                           clock_t      LAST_COUNTTIME,
                                           string& THROWTIME,
                                           string& COUNTTIME)
{
        spcl_dirs=SPCL_DIRS;
        numberof_cl=NUMBEROF_CL;
        biggest_clsz=BIGGEST_CLSZ;
        mean_clsz=MEAN_CLSZ;
        mean_clsz2=MEAN_CLSZ2;
        last_counttime=LAST_COUNTTIME;
        counttime=COUNTTIME;
        throwtime=THROWTIME;
}

bool one_result::percolate(int direction){
        manipdata<LONGBITS> *m=NULL;
        return (1 == m->bit_notzero(spcl_dirs,(LONGBITS)direction));
}
bool one_result::percolate(){
        manipdata<LONGBITS> *m=NULL;
        return (1 == m->notzero(spcl_dirs,(LONGBITS)42));
}
bool one_result::perc_lr(){
        manipdata<LONGBITS> *m=NULL;
        return (1 == m->bit_notzero(spcl_dirs,1));
}
bool one_result::perc_tb(){
        manipdata<LONGBITS> *m=NULL;
        return (1 == m->bit_notzero(spcl_dirs,2));
}
bool one_result::perc_all_dirs(int dim){
        manipdata<LONGBITS> *m=NULL;
        return (1 == m->allbits_notzero(spcl_dirs,(LONGBITS)dim));
}


// END OF CLASS one_result


class all_results {
public:
        NUMBER N;
        int dim;
        bool new_result;
        one_result last;

        std::list<LONGBITS> L_spcl_dirs;
        std::list<NUMBER>       L_numberof_cl;
        std::list<NUMBER>       L_biggest_clsz;
        std::list<REAL>         L_mean_clsz;
        std::list<REAL>         L_mean_clsz2;
        muvarskewkurt<REAL> spcl_cum;
        muvarskewkurt<REAL> spcl_lr_cum;
        muvarskewkurt<REAL> spcl_tb_cum;
        muvarskewkurt<REAL> spcl_alldirs_cum;
        muvarskewkurt<REAL> numberof_cl;
        muvarskewkurt<REAL> biggest_clsz;
        muvarskewkurt<REAL> mean_clsz;
        muvarskewkurt<REAL> mean_clsz2;
        COUNTER loop_no; 
        clock_t sum_time;
        clock_t sum_spsearch_time;
        
        all_results(){};
        all_results(NUMBER N_, int dim_);
        void set_N_and_dim(all_results* res, COUNTER ff_steps,NUMBER N,int dim);

        void add_result(one_result& one);       // a new result is added to the lists
        void no_result();                                       // no new result added
        void delete_lists();
        void compute_averages();
};

all_results::all_results(NUMBER N_, int dim_){
        N=N_;
        dim=dim_;
        new_result=false;
        loop_no=0;
        sum_time=0;
        sum_spsearch_time=0;
}

void set_N_and_dim(all_results* array, COUNTER size,NUMBER N,int dim){
        for (COUNTER i=0; i<=size;i++){
                array[i]=all_results(N,dim);
        }
}

void all_results::add_result(one_result& one){
        new_result=true;
        loop_no++;
        last=one;
        L_spcl_dirs.push_back   (one.spcl_dirs);
        L_numberof_cl.push_back (one.numberof_cl);
        L_biggest_clsz.push_back(one.biggest_clsz);
        L_mean_clsz.push_back   (one.mean_clsz);
        L_mean_clsz2.push_back  (one.mean_clsz2);
}
void all_results::no_result(){
        new_result=false;
}

void all_results::delete_lists(){       
        L_spcl_dirs.clear();
        L_numberof_cl.clear();
        L_biggest_clsz.clear();
        L_mean_clsz.clear();
        L_mean_clsz2.clear();
}

void all_results::compute_averages(){
        REAL dummy=1.0; // for calculate_moments result type
        spcl_cum        =calculate_moments<REAL,LONGBITS>(&manipdata<LONGBITS>::notzero,   (LONGBITS)42, L_spcl_dirs, dummy);
        spcl_lr_cum =calculate_moments<REAL,LONGBITS>(&manipdata<LONGBITS>::bit_notzero, (LONGBITS)1, L_spcl_dirs, dummy);
        spcl_tb_cum =calculate_moments<REAL,LONGBITS>(&manipdata<LONGBITS>::bit_notzero, (LONGBITS)2, L_spcl_dirs, dummy);
        spcl_alldirs_cum=calculate_moments<REAL,LONGBITS>
                             (&manipdata<LONGBITS>::allbits_notzero,(LONGBITS)dim, L_spcl_dirs, dummy);

        numberof_cl =calculate_moments<REAL,NUMBER>(&manipdata<NUMBER>::linear,     (NUMBER)42,     L_numberof_cl, dummy);
        biggest_clsz=calculate_moments<REAL,NUMBER>(&manipdata<NUMBER>::linear,     (NUMBER)42,    L_biggest_clsz, dummy);
        mean_clsz   =calculate_moments<REAL,REAL>(&manipdata<REAL>::linear,         (REAL)42,         L_mean_clsz, dummy);
        mean_clsz2  =calculate_moments<REAL,REAL>(&manipdata<REAL>::linear,         (REAL)42,        L_mean_clsz2, dummy);
}




} // end of namespace results

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

www.AndreasKrueger.de/thesis/code