code/inC/cellularAutomata.c

Go to the documentation of this file.

#include "cellularAutomata.h"


CA* randomizeToPercentage( CA* ca , int percent , int size ){
    if( ca == NULL ){
        ca = createCA( size );
    }
    int row, col;
    for( row=1 ; row<=ca->size ; row++ ){
        for( col=1 ; col<=ca->size ; col++ ){
            *ca->grid[row][col] = (rand() % 100) < percent;
        }
    }

    return ca;
}


void cpCA( CA* dest , CA* src ){
    int row, col;
    for( row=1 ; row<=src->size ; row++ ){
        for( col=1 ; col<=src->size ; col++ ){
            *dest->grid[row][col] = *src->grid[row][col];
        }
    }
}


void
freeCA( CA* ca ){
    int row, col;
    
    // the inner square
    for( row=1 ; row<=ca->size ; row++ ){
        for( col=1 ; col<=ca->size ; col++ ){
            free( ca->grid[row][col] );
        }
    }

    // all the rows
    for( row=0 ; row<ca->size+1 ; row++ ){
        free( ca->grid[row] );
    }

    free( ca->grid );
    free( ca );
}


CA**
randomCAs( int nCAs , int size ){
    CA** cas = (CA**) calloc( nCAs , sizeof(CA*) );
    int i;
    for( i=0 ; i<nCAs ; i++ ){
        cas[i] = randomCA( size );
    }
    return cas;
}


CA*
randomCA( int size ){
    CA* ca = createCA( size );
    int r,c;
    for( r=1 ; r<=size ; r++ ){
        for( c=1 ; c<=size ; c++ ){
            *ca->grid[r][c] = rand() % 2;
        }
    }
    return ca;
}



int*
getRule( char* file ){
    // allocate
    int* rule = (int*) calloc( 512 , sizeof(int) );
    char rawrule[512];
    FILE* rawrule_fp;
    
    // get the data
    if( (rawrule_fp = fopen(file,"r")) == NULL )
        perror( "fopen of raw rule file failed\n" );
    if( fgets(rawrule,513,rawrule_fp) == NULL )
        perror( "getline of raw rule failed\n" );
    fclose( rawrule_fp );

    // make the rule
    int i;
    for( i=0 ; i<512 ; i++ ){
        rule[i] = rawrule[i] == '1';
    }

    // free and return
    return rule;
}


CA*
getInitCA( char* file , int size ){
    // allocate
    int length = size*size;
    char rawCA[length];
    CA* ca = createCA( size );
    FILE* rawCA_fp;

    // the data
    if( (rawCA_fp = fopen(file,"r")) == NULL )
        perror( "getInitCA(): fopen of rawCA file failed" );
    if( fgets(rawCA,length+1,rawCA_fp) == NULL )
        perror( "getInitCA(): getline of rawCA file failed" );
    fclose( rawCA_fp );

    // set the values in the grid
    int r, c;
    for( r=1 ; r<=size ; r++ ){
        for( c=1 ; c<=size ; c++ ){
            *ca->grid[r][c] = rawCA[size*(r-1)+(c-1)] == '1';
        }
    }

    // free and return
    return ca;
}


int
finished( CA* ca ){
    int r, c, sum = 0;
    for( r=1 ; r<=ca->size ; r++ ){
        for( c=1 ; c<=ca->size ; c++ ){
            sum += *ca->grid[r][c];
        }
    }

    return sum == 0 || sum == ca->size*ca->size;
}


int
aggregate( CA* ca ){
    int r, c, sum = 0;
    for( r=1 ; r<=ca->size ; r++ ){
        for( c=1 ; c<=ca->size ; c++ ){
            sum += *ca->grid[r][c];
        }
    }
    return sum;
}


int
majority( CA* ca ){
    int sum = aggregate( ca );
    return 2*sum >= ca->size*ca->size;
}


CA*
createCA( int size ){
    // the easy allocation
    CA* ca = (CA*) malloc( sizeof(CA) );
    ca->size = size;

    // the innards
    int row, col;
    ca->grid = (int***) calloc( size+2 , sizeof(int**) );
    for( row = 0 ; row < size+2 ; row++ ){
        ca->grid[row] = (int**) calloc( size+2 , sizeof(int*) );
        if( row >= 1 && row <= size ){
            for( col = 1 ; col <= size ; col++ ){
                ca->grid[row][col] = (int*) malloc( sizeof(int) );
            }
        }
    }

    // the outtards
    int i;
    for( i=1 ; i<=size ; i++ ){
        ca->grid[i][0]      = ca->grid[i][size]; // left side wrap-around
        ca->grid[i][size+1] = ca->grid[i][1];    // right side wrap-around
        ca->grid[0][i]      = ca->grid[size][i]; // top wrap-around
        ca->grid[size+1][i] = ca->grid[1][i];    // bottom wrap-around
    }

    // the corners
    ca->grid[0][0]           = ca->grid[size][size];
    ca->grid[0][size+1]      = ca->grid[size][1];
    ca->grid[size+1][0]      = ca->grid[1][size];
    ca->grid[size+1][size+1] = ca->grid[1][1];

    return ca;
}


void
printInternalCA( CA* ca ){
    int r,c;
    for( r = 0 ; r < ca->size+2 ; r++ ){
        for( c = 0 ; c < ca->size+2 ; c++ ){
            printf( "%i " , *(ca->grid[r][c]) );
        }
        printf( "\n" );
    }
    printf( "\n" );
}


void
printCA( CA* ca ){
    int r,c;
    for( r = 1 ; r <= ca->size ; r++ ){
        for( c = 1 ; c <= ca->size ; c++ ){
            printf( "%i " , *(ca->grid[r][c]) );
        }
        printf( "\n" );
    }
    printf( "\n" );
}



void
step( CA* curr , CA* next , int* rules ){
    int r, c, rule;
    for( r = 1 ; r <= curr->size ; r++ ){
        for( c = 1 ; c <= curr->size ; c++ ){
            rule  =   1 * *curr->grid[r-1][c-1]
                  +   2 * *curr->grid[r-1][ c ]
                  +   4 * *curr->grid[r-1][c+1]
                  +   8 * *curr->grid[ r ][c-1]
                  +  16 * *curr->grid[ r ][ c ]
                  +  32 * *curr->grid[ r ][c+1]
                  +  64 * *curr->grid[r+1][c-1]
                  + 128 * *curr->grid[r+1][ c ]
                  + 256 * *curr->grid[r+1][c+1];
            *next->grid[r][c] = rules[rule];
        }
    }
    next->size = curr->size;
}


double
stepWithCount( CA* curr , CA* next , int* rules ){
    double sum = 0;
    int r, c, rule;
    for( r = 1 ; r <= curr->size ; r++ ){
        for( c = 1 ; c <= curr->size ; c++ ){
            rule  =   1 * *curr->grid[r-1][c-1]
                  +   2 * *curr->grid[r-1][ c ]
                  +   4 * *curr->grid[r-1][c+1]
                  +   8 * *curr->grid[ r ][c-1]
                  +  16 * *curr->grid[ r ][ c ]
                  +  32 * *curr->grid[ r ][c+1]
                  +  64 * *curr->grid[r+1][c-1]
                  + 128 * *curr->grid[r+1][ c ]
                  + 256 * *curr->grid[r+1][c+1];
            *next->grid[r][c] = rules[rule];
            sum += (double) rules[rule];
        }
    }
    next->size = curr->size;
    
    return sum;
}

---