Elementary cellular automaton/Random number generator: Difference between revisions

{{task}}

 

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.

;Reference:

* [http://www.cs.indiana.edu/~dgerman/2005midwestNKSconference/dgelbm.pdf Cellular automata: Is Rule 30 random]? (PDF).

 

=={{header|11l}}==

{{trans|Nim}}

 

 

F pow2(x)

print()

 

 

{{out}}

=={{header|C}}==

64-bits array size, cyclic borders.

#include <limits.h>

 

evolve(1, 30);

return 0;

{{out}}

<pre> 220 197 147 174 117 97 149 171 100 151</pre>

=={{header|C++}}==

We'll re-write the code of the parent task here.

#include <stdio.h>

 

printf("%u%c", byte(state), i ? ' ' : '\n');

return 0;

{{out}}

<pre>220 197 147 174 117 97 149 171 240 241</pre>

{{trans|C}}

Adapted from the C version, with improvements and bug fixes. Optimized for performance as requested in the task description. This is a lazy range.

 

struct CellularRNG {

CellularRNG(1, 30).take(10).writeln;

CellularRNG(1, 30).drop(2_000_000).front.writeln;

{{out}}

<pre>[220, 197, 147, 174, 117, 97, 149, 171, 100, 151]

44</pre>

Run-time: less than two seconds with the ldc2 compiler.

 

=={{header|F_Sharp|F#}}==

This task uses [[Elementary cellular automaton#The_Function]]

// Generate random numbers using Rule 30. Nigel Galloway: August 1st., 2019

eca 30 [|yield 1; yield! Array.zeroCreate 99|]|>Seq.chunkBySize 8|>Seq.map(fun n->n|>Array.mapi(fun n g->g.[0]<<<(7-n))|>Array.sum)|>Seq.take 10|>Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

=={{header|Go}}==

{{trans|C}}

 

import "fmt"

func main() {

evolve(1, 30)

 

{{out}}

Assume the comonadic solution given at [[Elementary cellular automaton#Haskell]] is packed in a module <code>CellularAutomata</code>

 

import Control.Comonad

import Data.List (unfoldr)

(fromList (1 : replicate size 0))

 

 

{{Out}}

Using the rule 30 CA it is possible to determine the <code>RandomGen</code> instance which could be utilized by the <code>Random</code> class:

 

 

instance RandomGen (Cycle Int) where

let x = c =>> step (rule 30)

in (fromBits (view x), x)

 

<pre>λ> let r30 = fromList [1,0,1,0,1,0,1,0,1,0,1,0,1] :: Cycle Int

=={{header|J}}==

ca is a cellular automata class. The rng class inherits ca and extends it with bit and byte verbs to sample the ca.

coclass'ca'

DOC =: 'locale creation: (RULE ; INITIAL_STATE) conew ''ca'''

byte =: [: #. [: , [: bit"0 (i.8)"_

coclass'base'

Having installed these into a j session we create and use the mathematica prng.

<pre>

byte__m"0 i.10

220 197 147 174 117 97 149 171 100 151

</pre>

 

=={{header|Julia}}==

{{trans|C, Go}}

B(x) = UInt64(1) << x

for p in 0:9

 

evolve(1, 30)

<pre>

220 197 147 174 117 97 149 171 100 151

=={{header|Kotlin}}==

{{trans|C}}

 

const val N = 64

fun main(args: Array<String>) {

evolve(1, 30)

 

{{out}}

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

<pre>{220, 197, 147, 174, 117, 97, 149, 171, 240, 241, 92, 18, 199, 27, 104, 8, 251, 167, 29, 112, 100, 103, 159, 129, 253}</pre>

=={{header|Nim}}==

{{trans|Kotlin}}

 

template pow2(x: uint): uint = 1u shl x

echo ""

 

 

{{out}}

{{Works with|Free Pascal}}

Using ROR and ROL is as fast as assembler and more portable.<BR>[https://tio.run/##7VZdb@pGEH33r5iHSEAvYJsQ0kBTifBxawmwC6a9bVVFjr3AKmZtrZdwaZS/Xjq7iwPckOThvvQhSHx45szMmbPD7qZBFgZxZZaG263HkzkPljBexeTcahmmuRAibZomYdU1vacpiWhQTfjclE/miHwVtxMRCHIrI26PQpaBWKwTHkfVdRLPMGs1TJamzlxdiGVsPJ45/W6vD32v82QAPJ4Nk4hAl8Tpgj49nrUnw6Hb7YEz8nsDDXA93xk6f7Z9xx2BOyq3B@gwTenqILQ9cD6PIOVJeG0/YfreYNLTgW3P8//wetBxRxN30FPOUdfpPxmrjGQImWyyqaBx1jLChGUCLcvg6zhZsSiDa6j9YFuWpT5a6OLajq9rsNFiPAQczbo3LQg0YUqZaNTRO1uxUNCEwWciOt701qdL0oSdV2xSgrF@J11hNk7ChEcGHLx@oegqH5kGiUQ3oYv6Rq29izB80lwQIBAh07aMOzKnDI1BtpQ0u/6kI6OG7m86BXiCw18I9asq9d/lXvvLKwBFBwFdCVAFAdZULHTFKFFsOMlWMda/1l0WMcibliBbxHBeg0@6gZahwg25XiRacQIOo@JQxBZlMWVk38ChE5PbL1OcGMk8iRaGr1gZR4Q8lBlC96uUl0A/SOJHPNDuYYiyu@NfpSRFmcguSZdMpF2Db11HIyExRQV2x7JOCb7gD8kl7@N5UmQbOvZmg62OAkEfiMOE/H816pUbx4cwYIDDi3PKNij4nGaC8OydLnGsNy5T0@loy807fe@X0tqHgxYfwDSnjCcxCjyHgEWgtJYPL9cB7jawQMxRzqL@@Ul/laQwUj1oj7q61HsCv7EseUevSf5B5IPIB5H/LZHj0/S9nXN/AkxSQiJBMpHv@L5d9i3c8ZzRbgukTTjYUPMNcM2pIDErFp4TwCzhkMn6Gf2HQDKDQrlRLxfgjoqsUNL73@8BX8IqlTguQCSwDu6JNOCJh4A@pqBqu9zdH9RHxcaTcs0QbeVH5qm7lCRvyeCDi4Os@uKc3BXSlZ4vLq9U2Z8rLaXOiQK5Fsfw0qGrEG7CmGSQEg7SiQIXykXfrgirZD5TaFrN2mHYy@Xyg@w@XymqbkVkTviJZfEXBASCQSv/tga2XIndNW3Xukr0TUfN@ilyeWk1CL6aJNjxzNMU4KceXkvHP0s2nATRLrqK5zNec1MakwjkQU2F8cY8Nepqlox63XgpJ16Try4MI@/bgFrNAvvqEuw6vi/rYNuXAOr5Cp9tOWJgX9hGzs04JHNe@y4ydu3H6kXju9hst/@GsziYZ9uKe76tTB7@Aw Try it online!] counting CPU-Cycles 32 vs 31 on Ryzen Zen1 per Byte -> 100Mb/s

//http://en.wikipedia.org/wiki/Next_State_Rule_30;

//http://mathworld.wolfram.com/Rule30.html

Task;

write(' <ENTER> ');readln;

{{out}}

<pre>//compiled 64-Bit

=={{header|Perl}}==

{{trans|Raku}}

sub new {

my $class = shift;

}

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

{{out}}

<pre>220 197 147 174 117 97 149 171 240 241</pre>

and with the changes marked [2] C++, Haskell, Perl, Python, Ruby, Scheme, and Sidef, but completely different to Rust and Tcl.

No attempt to optimise.

{{out}}

<pre>

=={{header|Python}}==

===Python: With zero padded ends===

 

def rule30bytes(lencells=100):

 

if __name__ == '__main__':

 

{{out}}

 

===Python: With wrapping of end cells===

cells = '1' + '0' * (lencells - 1)

gen = eca_wrap(cells, 30)

while True:

 

{{out}}

Implementation of [[Elementary cellular automaton]] is saved in "Elementary_cellular_automata.rkt"

 

;; below is the code from the parent task

(require "Elementary_cellular_automata.rkt")

(number->string (C30-rand-64 256) 16)

(number->string (C30-rand-64 256) 16)

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

has $.rule;

has @.code = $!rule.fmt('%08b').flip.comb».Int;

my Automaton $a .= new: :rule(30), :cells( flat 1, 0 xx 100 );

 

{{out}}

<pre>220 197 147 174 117 97 149 171 240 241</pre>

 

=={{header|Ruby}}==

eca = ElemCellAutomat.new("1"+"0"*(size-1), 30)

{{out}}

<pre>

 

=={{header|Rust}}==

//Assuming the code from the Elementary cellular automaton task is in the namespace.

fn main() {

}

}

{{out}}

<pre>

 

=={{header|Scheme}}==

; uses SRFI-1 library http://srfi.schemers.org/srfi-1/srfi-1.html

 

 

(random-r30 10)

 

{{out}}

 

=={{header|Sidef}}==

 

10.times {

};

say sum;

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

superclass ElementaryAutomaton

variable s

return [scan [join $bits ""] %b]

}

Demonstrating:

for {set r {}} {[llength $r]<10} {} {

lappend r [$rng rand]

}

{{out}}

220,197,147,174,241,126,135,130,143,234

{{libheader|Wren-big}}

As Wren cannot deal accurately with 64-bit unsigned integers and bit-wise operations thereon, we need to use BigInt here.

 

var n = 64

}

 

 

{{out}}

=={{header|zkl}}==

No attempts at extra credit and not fast.

fcn applyRule(rule,cells){

cells=String(cells[-1],cells,cells[0]); // wrap edges

}

n

Note that "var" in a function is "static" in C, ie function local variables, initialized once.

{{out}}

<pre>220,197,147,174,117,97,149,171,100,151,</pre>