Rule30
Rule 30 is a simple binary cellular automaton introduced by Stephen Wolfram on his book "A New Kind of Science" (1983).
This rule is of particular interest because it produces complex, seemingly random patterns from simple, well-defined rules. Because of this, Wolfram believes that Rule 30, and cellular automata in general, are the key to understanding how simple rules produce complex structures and behaviour in nature.
Rule 30 has also been used as a random number generator in Mathematica, and has also been proposed as a possible stream cipher for use in cryptography.
- Task
Write a program that prints out the evolution of the rule 30 on 1D celular automata as consecutive rows of ASCII characters. Showing the classic triangle:
. . . . . . . . . . . . . . . . . . . . . . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . # # # # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . # # # # . # # # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . . # . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . # # # # . . # # # # # # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . # # # . . . . . # . . . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . # # # # . # # . . # . . . # # # . . . . . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . . # . # # # # . # # . . # . . . . . . . . . . . . . . . . . . . . . . . . . # # . # # # # . . # # . # . . . . # . # # # # . . . . . . . . . . . . . . . . . . . . . . . # # . . # . . . # # # . . # # . . # # . # . . . # . . . . . . . . . . . . . . . . . . . . . # # . # # # # . # # . . # # # . # # # . . # # . # # # . . . . . . . . . . . . . . . . . . . # # . . # . . . . # . # # # . . . # . . # # # . . # . . # . . . . . . . . . . . . . . . . . # # . # # # # . . # # . # . . # . # # # # # . . # # # # # # # . . . . . . . . . . . . . . . # # . . # . . . # # # . . # # # # . # . . . . # # # . . . . . . # . . . . . . . . . . . . . # # . # # # # . # # . . # # # . . . . # # . . # # . . # . . . . # # # . . . . . . . . . . . # # . . # . . . . # . # # # . . # . . # # . # # # . # # # # . . # # . . # . . . . . . . . . # # . # # # # . . # # . # . . # # # # # # . . # . . . # . . . # # # . # # # # . . . . . . . # # . . # . . . # # # . . # # # # . . . . . # # # # . # # # . # # . . . # . . . # . . . . . # # . # # # # . # # . . # # # . . . # . . . # # . . . . # . . . # . # . # # # . # # # . . . # # . . # . . . . # . # # # . . # . # # # . # # . # . . # # # . # # . # . # . . . # . . # . # # . # # # # . . # # . # . . # # # . # . . . # . . # # # # . . . # . . # . # # . # # # # # #
(For standardization proposes, use rows of 50 cells, and just run the first 25th iterations.)
C
Simple implementation using pointers.
<lang c>
- include <stdio.h>
- define N 50
- define N_ITER 25
int rule30(int x1, int x2, int x3){
return !((x1 & (x2 | x3)) | (!x1 & !x2 & !x3));
}
int main(){ int i,k; int r1[N]={0}; int r2[N]={0}; int *p1,*p2,*temp;
p1=&r1[0]; //pointer a r1 p2=&r2[0]; //pointer a r2
r1[N/2]=1; //inicialización.
for (k=1;k<N_ITER;k++){ for (i=1;i<N-2;i++){ printf("%s ",*(p1+i+1)? "#":"."); *(p2+i+1)=rule30(*(p1+i),*(p1+i+1),*(p1+i+2)); } printf("\n"); temp=p1;p1=p2;p2=temp; //swap pointers del array }
return 0; }</lang>
Octave
<lang OCTAVE> clear all E=256; idx=round(E/2); z(1:1:E^2)=0; % init lattice z(idx)=1; % seed apex of triangle with a single cell A=2; % Number of bits rule30 uses 3 for n=1:1:E^2/2-E-2; % lines theta=0; % theta for a=0:1:A; theta=theta+2^a*z(n+A-a); endfor delta=(asin(sin (pi/4*(theta-3/4)))); z(n+E+1)=round( (4*delta + pi) / (2*pi) ); endfor imagesc(reshape(z,E,E)'); </lang>