code/inC/caga.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include "cellularAutomata.h"


/* declarations, definitions and descriptions below */
double* simulate( int** pop, int popSize, int caSize, int nStates, int nIters );
void usage();
int** getRules( char* file , int popSize );
void freedom( int** rules , int popSize , double* fits );
void outputFitnesses( double* fits , int popSize );
int verboseMain( char** argv );


char outFile[256];


int main( int argc , char** argv ){
    
    // check the arguments validity
    if( argc != 7 ){
        if( argc == 8 && strcmp("-v",argv[7]) == 0 ){
            return verboseMain(argv);
        }
        else{
            usage();
        }
    }


    // get the size of the population
    int popSize = atoi( argv[1] );

    
    // get the size of the CA
    int caSize = atoi( argv[2] );


    // get the number of the CA states that should be evaluated
    int nInitCaStates = atoi( argv[3] );


    // get the number of iterations of the CA
    int nCaIterations = atoi( argv[4] );


    // get the population itself
    int** pop = getRules( argv[5] , popSize );


    // get the output file name
    strcpy( outFile , argv[6] );

    
    // run the simulation
    double* fitnesses
        = simulate( pop , popSize ,  caSize , nInitCaStates , nCaIterations );


    // write the fitnesses
    outputFitnesses( fitnesses , popSize );


    // free and return
    freedom( pop , popSize , fitnesses );
    return 0;
}


int
verboseMain( char** argv ){
    // get the size of the population
    printf( "getting population size...\n" );fflush( stdout );
    int popSize = atoi( argv[1] );

    
    // get the size of the CA
    printf( "getting size of the CA...\n" );fflush( stdout );
    int caSize = atoi( argv[2] );


    // get the number of the CA states that should be evaluated
    printf( "getting the number of initial CA states...\n" );fflush( stdout );
    int nInitCaStates = atoi( argv[3] );


    // get the number of iterations of the CA
    printf( "getting the number of iterations for CA...\n" );fflush( stdout );
    int nCaIterations = atoi( argv[4] );


    // get the population itself
    printf( "getting the population...\n" );fflush( stdout );
    int** pop = getRules( argv[5] , popSize );


    // get the output file name
    strcpy( outFile , argv[6] );

    
    // run the simulation
    printf( "simulating...\n" );fflush( stdout );
    double* fitnesses
        = simulate( pop , popSize ,  caSize , nInitCaStates , nCaIterations );


    // write the fitnesses
    outputFitnesses( fitnesses , popSize );


    // free and return
    freedom( pop , popSize , fitnesses );
    return 0;
}


void
outputFitnesses( double* fits , int popSize ){
    FILE* fp;
    if( (fp = fopen(outFile,"w")) == NULL ){
        perror( "caga.outputFitnesses() couldn't open file" );
        exit( -1 );
    }

    int i;
    for( i=0 ; i<popSize ; i++ ){
        fprintf( fp , "%f\n" , fits[i] );
    }

    fclose( fp );
}


void
freedom( int** rules , int popSize , double* fits ){
    int i;
    for( i=0 ; i<popSize ; i++ ){
        free( rules[i] );
    }
    free( rules );
    free( fits );
}


int**
getRules( char* file , int popSize ){
    // allocate
    char rule[513];
    int** rules = (int**) calloc( popSize , sizeof(int*) );
    FILE* fp;

    if( (fp=fopen(file,"r")) == NULL ){
        perror( "ERROR caga.getRules() couldn't open file" );
        exit(-1);
    }

    int i, j;
    for( i=0 ; i<popSize ; i++ ){
        rules[i] = (int*) calloc( 512 , sizeof(int) );
        if( fgets(rule,513,fp) == NULL ){
            perror( "ERROR caga.getRules() error during reading file" );
            exit( -1 );
        }
        for( j=0 ; j<512 ; j++ ){
            rules[i][j] = rule[j] == '1';
        }
    }

    fclose( fp );
    
    return rules;
}


double*
simulate( int** pop , int popSize , int caSize , int nStates , int nIters ){
    // allocate
    double* fits = (double*) calloc( popSize , sizeof(double) );
    void* temp;
    CA** cas = randomCAs( nStates , caSize );
    CA* nextca = createCA( caSize );
    CA* ca = createCA( caSize );
    int majority, sum, nCorrect;

    // run the simulation
    int i, p, c;
    for( p=0 ; p<popSize ; p++ ){
        nCorrect = 0;
        for( c=0 ; c<nStates ; c++ ){
            cpCA( ca , cas[c] );
            majority = 2*aggregate(ca) > ca->size*ca->size ;
            for( i=0 ; i<nIters ; i++ ){
                if( i < nIters-1 ){
                    step( ca , nextca , pop[p] );
                }
                else{
                    // this is the last iteration, so get the percentage too
                    sum = stepWithCount( ca , nextca , pop[p] );
                }
                temp = ca;
                ca = nextca;
                nextca = temp;
            }
            if(   ((sum==0) && (majority==0))
               || ((sum==ca->size*ca->size) && (majority==1)) ){
                ++nCorrect;
            }
        }
        fits[p] = (double) nCorrect / (double) nIters;
    }

    // free and return
    freeCA( nextca );
    freeCA( ca );
    for( i=0 ; i<nStates ; i++ ){
        freeCA( cas[i] );
    }
    free( cas );
    return fits;
}


void
usage(){
printf( "\
USAGE: calcfits POPSIZE CASIZE INITCASTATES CAITERATIONS POPFILE FITOUT [-v]\n\
  Calculates the fitness of the entire population of size POPSIZE, where\n\
POPFILE is a file that contains only the members of the popoulation in order\n\
with no spaces.\n\
  The fitness is calculated by using the individuals in the population to try\n\
to classify INITCASTATES cellular automata each square of size CASIZE, all\n\
within CAITERATIONS steps each. The fitnesses are then all written to the\n\
file FITOUT.\n\
  The -v option indicates whether or not to be verbose." );
exit(0);
}

---