Elementary cellular automaton/Random number generator

From Rosetta Code
Elementary cellular automaton/Random number generator is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Rule 30 is considered to be chaotic enough to generate good pseudo-random numbers. As a matter of fact, rule 30 is used by the Mathematica software for its default random number generator.

Steven Wolfram's recommendation for random number generation from rule 30 consists in extracting successive bits in a fixed position in the array of cells, as the automaton changes state.

The purpose of this task is to demonstrate this. With the code written in the parent task, which you don't need to re-write here, show the ten first bytes that emerge from this recommendation. To be precise, you will start with a state of all cells but one equal to zero, and you'll follow the evolution of the particular cell whose state was initially one. Then you'll regroup those bits by packets of eight, reconstituting bytes with a little-endian encoding.

You can pick which ever length you want for the initial array but it should be visible in the code so that your output can be reproduced with an other language.

For extra-credits, you will make this algorithm run as fast as possible in your language, for instance with an extensive use of bitwise logic.

Reference

C

Note that output differs from Perls' due to the cyclic border here. <lang c>#include <stdio.h>

  1. include <limits.h>

typedef unsigned long long ull;

  1. define N (sizeof(ull) * CHAR_BIT)
  2. define B(x) (1ULL << (x))

void evolve(ull state, int rule) { int i, p, q, b[10] = {0};

for (p = 0; p < 10; p++) { for (q = 8; q--; ) { // MSB first? ull st = state; b[p] |= (st&1) << q;

for (state = i = 0; i < N; i++) if (rule & B(7 & (st>>(i-1) | st<<(N+1-i)))) state |= B(i); } printf(" %d", b[p]); } putchar('\n'); return; }

int main(int argc, char **argv) { evolve(1, 30); return 0; }</lang>

Output:
 220 197 147 174 117 97 149 171 100 151

Perl

Translation of: Perl 6

Since Perl 5 is currently much faster that Perl 6, we used a larger array size.

<lang perl>my $a = Automaton->new(30, 1, map 0, 1 .. 100);

for my $n (1 .. 10) { 

   my $sum = 0;
   for my $b (1 .. 8) {

$sum = $sum * 2 + $a->{cells}[0]; $a->next; 

   }
   print $sum, $n == 10 ? "\n" : " ";

}</lang>

Output:
220 197 147 174 117 97 149 171 240 241

Perl 6

A very easy to write, yet terribly slow version.

<lang perl6>my Automaton $a .= new: :rule(30), :cells( 1, 0 xx 40 );

say :2[$a++.cells[0] xx 8] xx 10; </lang>

Output:
220 197 147 174 117 39 39 136 93 11
Retrieved from "https://rosettacode.org/wiki/Elementary_cellular_automaton/Random_number_generator?oldid=243256"