code/inC/empiridata.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include "cellularAutomata.h"


#define MAX_CA_ITERATIONS 200


typedef struct {
    int isClassifiedCorrectly;
    int nsteps;
} SimResult;


/* Declarations, descriptions and definitions are further down. */
void simulate( CA* curr , CA* next , int rule[] , SimResult* result );
void usage();
void correctClassification( int argc , char** argv );


int main( int argc , char** argv ){
    if( argc < 2 ){
        usage();
        exit(-1);
    }

    // select the correct empirical data
    if( strcmp(argv[1],"--class") == 0 ){
        correctClassification(argc,argv);
    }
    else{
        usage();
        exit(-1);
    }
    
    return 0;
}


void
correctClassification( int argc , char** argv ){
    if( argc != 6 ){
        usage();
        exit(-1);
    }
    
    int* rule = getRule( argv[2] );
    int nTrials = atoi( argv[3] );
    int caSize = atoi( argv[4] );
    FILE* fp;
    if( (fp = fopen(argv[5],"w")) == NULL ){
        perror("correctClassification(): couldn't open output file");
    }
    CA* ca = createCA( caSize );
    CA* nextca = createCA( caSize );
    SimResult* result = (SimResult*) malloc( sizeof(SimResult) );

    // get the data
    int per, trial, correctTrials, avgIters;
    for( per=1 ; per<=99 ; per++ ){
        // simulate
        correctTrials = 0;
        avgIters = 0;
        for( trial=0 ; trial<nTrials ; trial++ ){
            randomizeToPercentage( ca , per , 0 );
            simulate( ca , nextca , rule , result );
            avgIters += result->nsteps;
            if( result->isClassifiedCorrectly ){
                ++correctTrials;
            }
        }
        // output the results
        fprintf( fp , "%f %f\n" , (double) correctTrials / nTrials
                                , (double) avgIters / nTrials );
    }

    // free and close the things
    free( result );
    fclose( fp );
    freeCA( ca );
    freeCA( nextca );
    free( rule );
}


// Returns 1 when the CA is classified AND classified correctly, zero otherwise
void
simulate( CA* curr , CA* next , int rule[] , SimResult* result ){
    int maj = majority( curr );
    int iters = 0;
    void* temp;
    while( iters < MAX_CA_ITERATIONS && !finished(curr) ){
        step( curr , next , rule );
        temp = curr;
        curr = next;
        next = temp;
        ++iters;
    }
    result->isClassifiedCorrectly = finished(curr) && maj == *curr->grid[1][1];
    result->nsteps = iters;
}


void usage(){
    printf("\
USAGE: There are multiple ways to use this program which are described below.\n\
empirical --class RULEFILE NTRIALS CASIZE RESULTFILE\n\
    Runs the experiment that determines the frequency with which the rule\n\
    contained in RULEFILE correctly classifies a CASIZExCASIZE CA over a\n\
    range of percentages. The experiment is averaged over NTRIALS trials,\n\
    since the generatation of the CAs based on a percentage doesn't *really*\n\
    give the perfect percentage, and the data is put into file with name\n\
    RESULTFILE.\n\
");
}

---