Rule30: Difference between revisions
mNo edit summary |
(Algebraic recurrence relation for rule 30,) |
||
(4 intermediate revisions by 2 users not shown) | |||
Line 1:
{{alertbox|Pink|Duplicate of task [[Elementary cellular automaton/Random Number Generator]] please merge with that page pending deletion.}}
[[Category:Cellular Automata]]
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.
Line 7 ⟶ 10:
;Task:
Write a program that prints out the evolution of the rule
<center>
. . . . . . . . . . . . . . . . . . . . . . . # . . . . . . . . . . . . . . . . . . . . . . .
Line 35 ⟶ 39:
</center>
(For
=={{header|C}}==
Line 46 ⟶ 51:
int rule30(int x1, int x2, int x3){
}
Line 67 ⟶ 71:
}
printf("\n");
temp=p1;p1=p2;p2=temp; //swap
}
return 0;
}</lang>
=={{header|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>
|
Latest revision as of 19:04, 26 July 2021
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>