Each step, the bits of the neighbor states are counted and this count is used to index a rule table to obtain the next state. A cells neighborhood is divided into 4 planes. The 9 bits in each plane can be individually selected to participate in the neighborhood count. In the example above all bits are selected for each neighbor and no bits are selected for the cell itself.
Randomly generated rule tables can be tested to find an interesting rule.
The following Golly rule tree:
Code: Select all
@RULE BitCounts003
@TREE
num_states=8
num_neighbors=8
num_nodes=98
1 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0
1 5 5 5 5 5 5 5 5
2 0 0 0 0 0 0 0 2
2 0 0 0 2 0 2 2 0
3 1 1 1 3 1 3 3 4
1 7 7 7 7 7 7 7 7
2 0 2 2 0 2 0 0 6
3 1 3 3 4 3 4 4 7
2 2 0 0 6 0 6 6 0
3 3 4 4 7 4 7 7 9
2 0 6 6 0 6 0 0 0
3 4 7 7 9 7 9 9 11
4 5 8 8 10 8 10 10 12
1 6 6 6 6 6 6 6 6
2 6 0 0 0 0 0 0 14
3 7 9 9 11 9 11 11 15
4 8 10 10 12 10 12 12 16
2 0 0 0 14 0 14 14 0
3 9 11 11 15 11 15 15 18
4 10 12 12 16 12 16 16 19
1 2 2 2 2 2 2 2 2
2 0 14 14 0 14 0 0 21
3 11 15 15 18 15 18 18 22
4 12 16 16 19 16 19 19 23
5 13 17 17 20 17 20 20 24
2 14 0 0 21 0 21 21 14
3 15 18 18 22 18 22 22 26
4 16 19 19 23 19 23 23 27
5 17 20 20 24 20 24 24 28
2 0 21 21 14 21 14 14 0
3 18 22 22 26 22 26 26 30
4 19 23 23 27 23 27 27 31
5 20 24 24 28 24 28 28 32
2 21 14 14 0 14 0 0 0
3 22 26 26 30 26 30 30 34
4 23 27 27 31 27 31 31 35
5 24 28 28 32 28 32 32 36
6 25 29 29 33 29 33 33 37
2 14 0 0 0 0 0 0 0
3 26 30 30 34 30 34 34 39
4 27 31 31 35 31 35 35 40
5 28 32 32 36 32 36 36 41
6 29 33 33 37 33 37 37 42
1 4 4 4 4 4 4 4 4
2 0 0 0 0 0 0 0 44
3 30 34 34 39 34 39 39 45
4 31 35 35 40 35 40 40 46
5 32 36 36 41 36 41 41 47
6 33 37 37 42 37 42 42 48
2 0 0 0 44 0 44 44 0
3 34 39 39 45 39 45 45 50
4 35 40 40 46 40 46 46 51
5 36 41 41 47 41 47 47 52
6 37 42 42 48 42 48 48 53
7 38 43 43 49 43 49 49 54
1 3 3 3 3 3 3 3 3
2 0 44 44 0 44 0 0 56
3 39 45 45 50 45 50 50 57
4 40 46 46 51 46 51 51 58
5 41 47 47 52 47 52 52 59
6 42 48 48 53 48 53 53 60
7 43 49 49 54 49 54 54 61
2 44 0 0 56 0 56 56 0
3 45 50 50 57 50 57 57 63
4 46 51 51 58 51 58 58 64
5 47 52 52 59 52 59 59 65
6 48 53 53 60 53 60 60 66
7 49 54 54 61 54 61 61 67
2 0 56 56 0 56 0 0 0
3 50 57 57 63 57 63 63 69
4 51 58 58 64 58 64 64 70
5 52 59 59 65 59 65 65 71
6 53 60 60 66 60 66 66 72
7 54 61 61 67 61 67 67 73
8 55 62 62 68 62 68 68 74
2 56 0 0 0 0 0 0 6
3 57 63 63 69 63 69 69 76
4 58 64 64 70 64 70 70 77
5 59 65 65 71 65 71 71 78
6 60 66 66 72 66 72 72 79
7 61 67 67 73 67 73 73 80
8 62 68 68 74 68 74 74 81
2 0 0 0 6 0 6 6 0
3 63 69 69 76 69 76 76 83
4 64 70 70 77 70 77 77 84
5 65 71 71 78 71 78 78 85
6 66 72 72 79 72 79 79 86
7 67 73 73 80 73 80 80 87
8 68 74 74 81 74 81 81 88
2 0 6 6 0 6 0 0 2
3 69 76 76 83 76 83 83 90
4 70 77 77 84 77 84 84 91
5 71 78 78 85 78 85 85 92
6 72 79 79 86 79 86 86 93
7 73 80 80 87 80 87 87 94
8 74 81 81 88 81 88 88 95
9 75 82 82 89 82 89 89 96
@COLORS
0 0 0 0
1 255 0 0
2 0 255 0
3 0 0 255
4 255 255 0
5 0 255 255
6 255 0 255
7 92 36 110
This code was used:
Code: Select all
/* Put your state count, neighbor count, and function here */
final static int numStates = 8;
final static int numNeighbors = 8;
final static int neighborSelector[][] =
{
{1,1,1,1,0,1,1,1,1},
{1,1,1,1,0,1,1,1,1},
{1,1,1,1,0,1,1,1,1},
{1,1,1,1,0,1,1,1,1},
};
final static int ruleTable[] =
{0,0,0,0,0,5,0,7,0,0,6,0,2,6,0,0,0,4,0,3,0,0,7,0,5,6,0,7,0,0,5,0,0,0,0,0,0};
/* order for nine neighbors is nw, ne, sw, se, n, w, e, s, c */
/* order for five neighbors is n, w, e, s, c */
int f(int[] a)
{
int bitCount =
((a[0] ) & neighborSelector[0][0]) +
((a[0] >> 1) & neighborSelector[1][0]) +
((a[0] >> 2) & neighborSelector[2][0]) +
((a[0] >> 3) & neighborSelector[3][0]) +
((a[4] ) & neighborSelector[0][1]) +
((a[4] >> 1) & neighborSelector[1][1]) +
((a[4] >> 2) & neighborSelector[2][1]) +
((a[4] >> 3) & neighborSelector[3][1]) +
((a[1] ) & neighborSelector[0][2]) +
((a[1] >> 1) & neighborSelector[1][2]) +
((a[1] >> 2) & neighborSelector[2][2]) +
((a[1] >> 3) & neighborSelector[3][2]) +
((a[5] ) & neighborSelector[0][3]) +
((a[5] >> 1) & neighborSelector[1][3]) +
((a[5] >> 2) & neighborSelector[2][3]) +
((a[5] >> 3) & neighborSelector[3][3]) +
((a[8] ) & neighborSelector[0][4]) +
((a[8] >> 1) & neighborSelector[1][4]) +
((a[8] >> 2) & neighborSelector[2][4]) +
((a[8] >> 3) & neighborSelector[3][4]) +
((a[6] ) & neighborSelector[0][5]) +
((a[6] >> 1) & neighborSelector[1][5]) +
((a[6] >> 2) & neighborSelector[2][5]) +
((a[6] >> 3) & neighborSelector[3][5]) +
((a[2] ) & neighborSelector[0][6]) +
((a[2] >> 1) & neighborSelector[1][6]) +
((a[2] >> 2) & neighborSelector[2][6]) +
((a[2] >> 3) & neighborSelector[3][6]) +
((a[7] ) & neighborSelector[0][7]) +
((a[7] >> 1) & neighborSelector[1][7]) +
((a[7] >> 2) & neighborSelector[2][7]) +
((a[7] >> 3) & neighborSelector[3][7]) +
((a[3] ) & neighborSelector[0][8]) +
((a[3] >> 1) & neighborSelector[1][8]) +
((a[3] >> 2) & neighborSelector[2][8]) +
((a[3] >> 3) & neighborSelector[3][8]);
return ruleTable[bitCount];
}
Brian Prentice