cellular automata

Programming Questions

ahhreeyell

in Programming Questions • 1 year ago

Hi, I'm having some trouble understanding the code in this cellular automata example: http://processing.org/learning/topics/wolfram.html

I don't quite understand what's going on in the class CA—here's the portion of code I need help understanding:

class CA {
int[] cells; // An array of 0s and 1s
int generation; // How many generations?
int scl; // How many pixels wide/high is each cell?
int[] rules; // An array to store the ruleset, for example {0,1,1,0,1,1,0,1}
CA(int[] r) {
rules = r;
scl = 1;
cells = new int[width/scl];
restart();
}
CA() {
scl = 1;
cells = new int[width/scl];
randomize();
restart();
}
// Set the rules of the CA
void setRules(int[] r) {
rules = r;
}
// Make a random ruleset
void randomize() {
for (int i = 0; i < 8; i++) {
rules[i] = int(random(2));
}
}
// Reset to generation 0
void restart() {
for (int i = 0; i < cells.length; i++) {
cells[i] = 0;
}
cells[cells.length/2] = 1; // We arbitrarily start with just the middle cell having a state of "1"
generation = 0;
}
// The process of creating the new generation
void generate() {
// First we create an empty array for the new values
int[] nextgen = new int[cells.length];
// For every spot, determine new state by examing current state, and neighbor states
// Ignore edges that only have one neighor
for (int i = 1; i < cells.length-1; i++) {
int left = cells[i-1]; // Left neighbor state
int me = cells[i]; // Current state
int right = cells[i+1]; // Right neighbor state
nextgen[i] = rules(left,me,right); // Compute next generation state based on ruleset
}
// Copy the array into current value
cells = (int[]) nextgen.clone();
generation++;
}
// This is the easy part, just draw the cells, fill 255 for '1', fill 0 for '0'
void render() {
for (int i = 0; i < cells.length; i++) {
if (cells[i] == 1) fill(255);
else fill(0);
noStroke();
rect(i*scl,generation*scl, scl,scl);
}
}
// Implementing the Wolfram rules
// Could be improved and made more concise, but here we can explicitly see what is going on for each case
int rules (int a, int b, int c) {
if (a == 1 && b == 1 && c == 1) return rules[0];
if (a == 1 && b == 1 && c == 0) return rules[1];
if (a == 1 && b == 0 && c == 1) return rules[2];
if (a == 1 && b == 0 && c == 0) return rules[3];
if (a == 0 && b == 1 && c == 1) return rules[4];
if (a == 0 && b == 1 && c == 0) return rules[5];
if (a == 0 && b == 0 && c == 1) return rules[6];
if (a == 0 && b == 0 && c == 0) return rules[7];
return 0;
}
// The CA is done if it reaches the bottom of the screen
boolean finished() {
if (generation > height/scl) {
return true;
} else {
return false;
}
}
}

Thanks!

Replies(4)

hellochar

Re: cellular automata

1 year ago

What part are you specifically confused about?

ahhreeyell

Re: cellular automata

1 year ago

Well, for one thing, I don't understand this part:

CA(int[] r) {
rules = r;
scl = 1;
cells = new int[width/scl];
restart();
}
CA() {
scl = 1;
cells = new int[width/scl];
randomize();
restart();
}

jbum

Re: cellular automata

1 year ago

There are two keys to understanding this code.

1) You need to undertand what the cellular autometa is doing.

2) You need to be famliar with arrays and array syntax. If you're not, go read up about Arrays in processing, and come back when you understand the basics.

3) Okay three keys. You need to understand the basics of Object Oriented programming in Processing or Java.

Also, the second constructor has a bug - it doesn't allocate an empty rule set. You can fix it by inserting the following just before line 12 (before the line that says "randomize();")

rules = new int[8];

Here is some code to exercise this class, in case you don't have it.

CA ca;

void setup()

{

size(500, 400);

ca = new CA();

}

void draw()

{

ca.generate();

ca.render();

}

Perhaps a little easier to see what's going on if you run it. But basically, the two routines you posted are constructors.

The first receives a set of rules, which are an array of 8 numbers (each of which is 1 or 0). You can see the effect of each rule in lines 74-82. Basically for each pattern of 3 bits, it selects one of the rules and uses that to generate the next row. So it scans through the parent cells, and for each group of 3 cells (a,b,c) it generates a new cell z, which is based on the 8 possible combinations of a,b,c.

a b c

Oh, and the author is right, that code "c ould be improved and made more concise". Like it could be reduced to a single line, but it is perhaps easier to understand as is.

The first constructor is passed a set of 8 rules. It initializes a set of cells (one cell for each pixel), and initializes some other variables. The second constructor is essentially the same, but it creates a random set of rules. That's the version I used in my sample code.

asimes

Re: cellular automata

1 year ago

The rules mentioned are not specific to Processing, they were invented by Stephen Wolfram and are Wolfram code. I'd recommend reading about this before making sense of the code: