1. 
   
2. // The Nature of Code
3. // Daniel Shiffman
4. // http://natureofcode.com
5. // Wolfram Cellular Automata
6. 
   
7. // Simple demonstration of a Wolfram 1-dimensional cellular automata
8. 
   
9. CA ca; // An instance object to describe the Wolfram basic Cellular Automata
10. 
    
11. 
    
12. void setup() {
13.   size(800, 400);
14.   background(255);
15.   ca = new CA();                 // Initialize CA
16. }
17. 
    
18. void draw() {
19.   ca.display();    // Draw the CA
20.   if (ca.generation < height/ca.w) {
21.     ca.generate();
22.   }
23.   
24. }
25. 
    
26. class CA {
27. 
    
28.   int[] cells;     // An array of 0s and 1s 
29.   int generation;  // How many generations?
30. 
    
31.   int[] ruleset = {0, 1, 0, 1, 1, 0, 1, 0};     // An array to store the ruleset, for example {0,1,1,0,1,1,0,1}
32. 
    
33.   int w = 10;
34. 
    
35.   CA() {
36.     cells = new int[width/w];
37.     for (int i = 0; i < cells.length; i++) {
38.       cells[i] = 0;
39.     }
40.     cells[cells.length/2] = 1;    // We arbitrarily start with just the middle cell having a state of "1"
41.     generation = 0;
42.   }
43. 
    
44.   // The process of creating the new generation
45.   void generate() {
46.     // First we create an empty array for the new values
47.     int[] nextgen = new int[cells.length];
48.     // For every spot, determine new state by examing current state, and neighbor states
49.     // Ignore edges that only have one neighor
50.     for (int i = 1; i < cells.length-1; i++) {
51.       int left = cells[i-1];   // Left neighbor state
52.       int me = cells[i];       // Current state
53.       int right = cells[i+1];  // Right neighbor state
54.       nextgen[i] = rules(left, me, right); // Compute next generation state based on ruleset
55.     }
56.     // The current generation is the new generation
57.     cells = nextgen;
58.     generation++;
59.     
60. 
    
61.     
62.   }
63. 
    
64.   // This is the easy part, just draw the cells, fill 255 for '1', fill 0 for '0'
65.   void display() {
66.     for (int i = 0; i < cells.length; i++) {
67.       if (cells[i] == 1) fill(0);
68.       else               fill(255);
69.       noStroke();
70.       rect(i*w, generation*w, w, w);
71.     }
72.     
73.     
74.   }
75. 
    
76. 
    
77. 
    
78.   // Implementing the Wolfram rules
79.   // Could be improved and made more concise, but here we can explicitly see what is going on for each case
80.   int rules (int a, int b, int c) {
81.     if (a == 1 && b == 1 && c == 1) return ruleset[0];
82.     if (a == 1 && b == 1 && c == 0) return ruleset[1];
83.     if (a == 1 && b == 0 && c == 1) return ruleset[2];
84.     if (a == 1 && b == 0 && c == 0) return ruleset[3];
85.     if (a == 0 && b == 1 && c == 1) return ruleset[4];
86.     if (a == 0 && b == 1 && c == 0) return ruleset[5];
87.     if (a == 0 && b == 0 && c == 1) return ruleset[6];
88.     if (a == 0 && b == 0 && c == 0) return ruleset[7];
89.     return 0;
90.   }
91. }

I was curious about his exercise 7.1 "expand example 7.1 to have the following feature: when the CA reaches the bottom of the Processing window, the CA starts over with a new, random ruleset". Not very strong on restarting operations in general. I've tried a variety of 'if height is reached' type statements. I would take a hint here.. unclear. I feel like it should be in the generate function because the rule should change not just how it's drawn.