Rosetta Code

Elementary cellular automaton/Random number generator: Difference between revisions

Page Discussion

Elementary cellular automaton/Random number generator (view source)

Revision as of 09:10, 17 March 2024

25,786 bytes added ,  2 months ago
Added FreeBASIC
(→‎{{header|Tcl}}: Added zkl)
(Added FreeBASIC)
 
(43 intermediate revisions by 17 users not shown)
Line 1:
{{draft task}}
[[wp:Rule 30|Rule 30]] is considered to be chaotic enough to generate good pseudo-random numbers. As a matter of fact, for a long time rule 30 iswas used by the [[wp:Mathematica|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.
Line 12:
;Reference:
* [http://www.cs.indiana.edu/~dgerman/2005midwestNKSconference/dgelbm.pdf Cellular automata: Is Rule 30 random]? (PDF).
 
 
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">V n = 64
 
F pow2(x)
R UInt64(1) << x
 
F evolve(UInt64 =state; rule)
L 10
V b = UInt64(0)
L(q) (7 .. 0).step(-1)
V st = state
b [|]= (st [&] 1) << q
state = 0
L(i) 0 .< :n
V t = ((st >> (i - 1)) [|] (st << (:n + 1 - i))) [&] 7
I (rule [&] pow2(t)) != 0
state [|]= pow2(i)
print(‘ ’b, end' ‘’)
print()
 
evolve(1, 30)</syntaxhighlight>
 
{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|C}}==
64-bits array size, cyclic borders.
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <limits.h>
 
Line 44 ⟶ 75:
evolve(1, 30);
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 220 197 147 174 117 97 149 171 100 151</pre>
Line 50 ⟶ 81:
=={{header|C++}}==
We'll re-write the code of the parent task here.
<langsyntaxhighlight lang="cpp">#include <bitset>
#include <stdio.h>
 
Line 87 ⟶ 118:
printf("%u%c", byte(state), i ? ' ' : '\n');
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>220 197 147 174 117 97 149 171 240 241</pre>
Line 94 ⟶ 125:
{{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.
<langsyntaxhighlight lang="d">import std.stdio, std.range, std.typecons;
 
struct CellularRNG {
Line 145 ⟶ 176:
CellularRNG(1, 30).take(10).writeln;
CellularRNG(1, 30).drop(2_000_000).front.writeln;
}</langsyntaxhighlight>
{{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|FreeBASIC}}==
{{trans|Go}}
<syntaxhighlight lang="vbnet">Const n As Uinteger = 64
 
#define pow2(x) Culng(1) Shl x
 
Sub Evolve(state As Integer, rule As Integer)
Dim As Integer i, p, q
Dim As Ulongint b, st, t1, t2, t3
For p = 0 To 9
b = 0
For q = 7 To 0 Step -1
st = state
b Or= (st And 1) Shl q
state = 0
For i = 0 To n - 1
t1 = Iif(i > 0, st Shr (i - 1), st Shr 63)
Select Case i
Case 0: t2 = st Shl 1
Case 1: t2 = st Shl 63
Case Else: t2 = st Shl (n + 1 - i)
End Select
t3 = 7 And (t1 Or t2)
If (rule And pow2(t3)) <> 0 Then state Or= pow2(i)
Next i
Next q
Print Using "####"; b;
Next p
Print
End Sub
 
Evolve(1, 30)
 
Sleep</syntaxhighlight>
{{out}}
<pre> 220 197 147 174 117 97 149 171 100 151</pre>
 
=={{header|F_Sharp|F#}}==
This task uses [[Elementary cellular automaton#The_Function]]
<syntaxhighlight lang="fsharp">
// 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 ""
</syntaxhighlight>
{{out}}
<pre>
220 197 147 174 117 97 149 171 240 241
</pre>
 
=={{header|Go}}==
{{trans|C}}
<syntaxhighlight lang="go">package main
 
import "fmt"
 
const n = 64
 
func pow2(x uint) uint64 {
return uint64(1) << x
}
 
func evolve(state uint64, rule int) {
for p := 0; p < 10; p++ {
b := uint64(0)
for q := 7; q >= 0; q-- {
st := state
b |= (st & 1) << uint(q)
state = 0
for i := uint(0); i < n; i++ {
var t1, t2, t3 uint64
if i > 0 {
t1 = st >> (i - 1)
} else {
t1 = st >> 63
}
if i == 0 {
t2 = st << 1
} else if i == 1 {
t2 = st << 63
 
} else {
t2 = st << (n + 1 - i)
}
t3 = 7 & (t1 | t2)
if (uint64(rule) & pow2(uint(t3))) != 0 {
state |= pow2(i)
}
}
}
fmt.Printf("%d ", b)
}
fmt.Println()
}
 
func main() {
evolve(1, 30)
}</syntaxhighlight>
 
{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|Haskell}}==
 
Assume the comonadic solution given at [[Elementary cellular automaton#Haskell]] is packed in a module <code>CellularAutomata</code>
 
<syntaxhighlight lang="haskell">import CellularAutomata (fromList, rule, runCA)
import Control.Comonad
import Data.List (unfoldr)
 
rnd = fromBits <$> unfoldr (pure . splitAt 8) bits
where
size = 80
bits =
extract
<$> runCA
(rule 30)
(fromList (1 : replicate size 0))
 
fromBits = foldl ((+) . (2 *)) 0</syntaxhighlight>
 
{{Out}}
<pre>λ> take 10 rnd
[220,197,147,174,117,97,149,171,240,241]</pre>
 
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:
 
<syntaxhighlight lang="haskell">import System.Random
 
instance RandomGen (Cycle Int) where
next c =
let x = c =>> step (rule 30)
in (fromBits (view x), x)
split = (,) <*> (fromList . reverse . view)</syntaxhighlight>
 
<pre>λ> let r30 = fromList [1,0,1,0,1,0,1,0,1,0,1,0,1] :: Cycle Int
 
λ> take 15 $ randoms r30
[7509,4949,2517,2229,2365,2067,6753,5662,5609,7576,2885,3017,2912,5081,2356]
 
λ> take 30 $ randomRs ('A','J') r30
"DHJHHFJHBDDFCBHACHDEHDHFBAEJFE"</pre>
 
We can compare it with standard generator on a small integer range, using simple bin counter:
 
<pre>λ> let bins lst = [ (n, length (filter (==n) lst)) | n <- nub lst]
 
λ> bins . take 10000 . randomRs ('A','J') $ r30
[('D',1098),('H',1097),('J',1093),('F',850),('B',848),('C',1014),('A',1012),('E',1011),('G',1253),('I',724)]
 
λ> bins . take 10000 . randomRs ('A','J') <$> getStdGen
[('G',975),('B',1035),('F',970),('J',1034),('I',956),('H',984),('C',1009),('E',1023),('A',1009),('D',1005)]</pre>
 
=={{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.
<syntaxhighlight lang="j">
<lang J>
coclass'ca'
DOC =: 'locale creation: (RULE ; INITIAL_STATE) conew ''ca'''
Line 165 ⟶ 350:
byte =: [: #. [: , [: bit"0 (i.8)"_
coclass'base'
</syntaxhighlight>
</lang>
Having installed these into a j session we create and use the mathematica prng.
<pre>
Line 172 ⟶ 357:
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|Java}}==
<syntaxhighlight lang="java">
public class ElementaryCellularAutomatonRandomNumberGenerator {
 
public static void main(String[] aArgs) {
final int seed = 989898989;
evolve(seed, 30);
}
private static void evolve(int aState, int aRule) {
long state = aState;
for ( int i = 0; i <= 9; i++ ) {
int b = 0;
for ( int q = 7; q >= 0; q-- ) {
long stateCopy = state;
b |= ( stateCopy & 1 ) << q;
state = 0;
for ( int j = 0; j < BIT_COUNT; j++ ) {
long t = ( stateCopy >>> ( j - 1 ) ) | ( stateCopy << ( BIT_COUNT + 1 - j ) ) & 7;
if ( ( aRule & ( 1L << t ) ) != 0 ) {
state |= 1 << j;
}
}
}
System.out.print(" " + b);
}
System.out.println();
}
private static final int BIT_COUNT = 64;
 
}
</syntaxhighlight>
{{ out }}
<pre>
231 223 191 126 253 251 247 239 223 191
</pre>
 
=={{header|jq}}==
'''Works with jq and gojq, the C and Go implementations of jq'''
 
The following also works with jaq, the Rust implementation of jq, provided
the "include" directive is replaced with the set of definitions from
the parent task, and that a suitable alternative to 100*"0" is
presented.
 
<syntaxhighlight lang=jq>
include "elementary-cellular-automaton" {search : "."};
 
# If using jq, the def of _nwise can be omitted.
def _nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
 
# Input: an array of bits represented by 0s, 1s, "0"s, or "1"s
# Output: the corresponding decimal on the assumption that the leading bits are least significant,
# e.g. [0,1] => 2
def binary2number:
reduce (.[]|tonumber) as $x ({p:1}; .n += .p * $x | .p *= 2) | .n;
("1" + 100 * "0" ) | [automaton(30; 80) | .[0:1]] | [_nwise(8) | reverse | binary2number]
</syntaxhighlight>
{{output}}
<pre>
[220,197,147,174,117,97,149,171,240,241]
</pre>
 
=={{header|Julia}}==
{{trans|C, Go}}
<syntaxhighlight lang="julia">function evolve(state, rule, N=64)
B(x) = UInt64(1) << x
for p in 0:9
b = UInt64(0)
for q in 7:-1:0
st = UInt64(state)
b |= (st & 1) << q
state = UInt64(0)
for i in 0:N-1
t1 = (i > 0) ? st >> (i - 1) : st >> (N - 1)
t2 = (i == 0) ? st << 1 : (i == 1) ? st << (N - 1) : st << (N + 1 - i)
if UInt64(rule) & B(7 & (t1 | t2)) != 0
state |= B(i)
end
end
end
print("$b ")
end
println()
end
 
evolve(1, 30)
</syntaxhighlight>{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|Kotlin}}==
{{trans|C}}
<syntaxhighlight lang="scala">// version 1.1.51
 
const val N = 64
 
fun pow2(x: Int) = 1L shl x
 
fun evolve(state: Long, rule: Int) {
var state2 = state
for (p in 0..9) {
var b = 0
for (q in 7 downTo 0) {
val st = state2
b = (b.toLong() or ((st and 1L) shl q)).toInt()
state2 = 0L
for (i in 0 until N) {
val t = ((st ushr (i - 1)) or (st shl (N + 1 - i)) and 7L).toInt()
if ((rule.toLong() and pow2(t)) != 0L) state2 = state2 or pow2(i)
}
}
print(" $b")
}
println()
}
 
fun main(args: Array<String>) {
evolve(1, 30)
}</syntaxhighlight>
 
{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">FromDigits[#, 2] & /@ Partition[Flatten[CellularAutomaton[30, {{1}, 0}, {200, 0}]], 8]</syntaxhighlight>
{{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}}
<syntaxhighlight lang="nim">const N = 64
 
template pow2(x: uint): uint = 1u shl x
 
proc evolve(state: uint; rule: Positive) =
var state = state
for _ in 1..10:
var b = 0u
for q in countdown(7, 0):
let st = state
b = b or (st and 1) shl q
state = 0
for i in 0u..<N:
let t = (st shr (i - 1) or st shl (N + 1 - i)) and 7
if (rule.uint and pow2(t)) != 0: state = state or pow2(i)
stdout.write ' ', b
echo ""
 
evolve(1, 30)</syntaxhighlight>
 
{{out}}
<pre> 220 197 147 174 117 97 149 171 100 151</pre>
 
=={{header|Pascal}}==
{{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
<syntaxhighlight lang="pascal">Program Rule30;
//http://en.wikipedia.org/wiki/Next_State_Rule_30;
//http://mathworld.wolfram.com/Rule30.html
{$IFDEF FPC}
{$Mode Delphi}{$ASMMODE INTEL}
{$OPTIMIZATION ON,ALL}
// {$CODEALIGN proc=1}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
SysUtils;
const
maxRounds = 2*1000*1000;
rounds = 10;
 
var
Rule30_State : Uint64;
 
function GetCPU_Time: int64;
type
TCpu = record
HiCpu,
LoCpu : Dword;
end;
var
Cput : TCpu;
begin
asm
RDTSC;
MOV Dword Ptr [CpuT.LoCpu],EAX
MOV Dword Ptr [CpuT.HiCpu],EDX
end;
with Cput do
result := int64(HiCPU) shl 32 + LoCpu;
end;
 
procedure InitRule30_State;inline;
begin
Rule30_State:= 1;
end;
 
procedure Next_State_Rule_30;inline;
var
run, prev,next: Uint64;
begin
run := Rule30_State;
Prev := RORQword(run,1);
next := ROLQword(run,1);
Rule30_State := (next OR run) XOR prev;
end;
 
function NextRule30Byte:NativeInt;
//64-BIT can use many registers
//32-Bit still fast
var
run, prev,next: Uint64;
myOne : UInt64;
Begin
run := Rule30_State;
result := 0;
myOne := 1;
//Unrolling and inlining Next_State_Rule_30 by hand
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
run := (next OR run) XOR prev;
 
result := (result+result) OR (run AND myOne);
next := ROLQword(run,1);
Prev := RORQword(run,1);
Rule30_State := (next OR run) XOR prev;
end;
 
procedure Speedtest;
var
T1,T0 : INt64;
i: NativeInt;
Begin
writeln('Speedtest for statesize of ',64,' bits');
//Warm up start to wake up CPU takes some time
For i := 100*1000*1000-1 downto 0 do
Next_State_Rule_30;
 
T0 := GetCPU_Time;
InitRule30_State;
For i := maxRounds-1 downto 0 do
NextRule30Byte;
T1 := GetCPU_Time;
writeln(NextRule30Byte);
writeln('cycles per Byte : ',(T1-t0)/maxRounds:0:2);
writeln;
end;
 
procedure Task;
var
i: integer;
Begin
writeln('The task ');
InitRule30_State;
For i := 1 to rounds do
write(NextRule30Byte:4);
writeln;
end;
 
Begin
SpeedTest;
Task;
write(' <ENTER> ');readln;
end.</syntaxhighlight>
{{out}}
<pre>//compiled 64-Bit
Speedtest for statesize of 64 bits
44
cycles per Byte : 30.95
 
The task
220 197 147 174 117 97 149 171 100 151
<ENTER>
 
//compiled 32-Bit
Speedtest for statesize of 64 bits
44
cycles per Byte : 128.56
 
The task
220 197 147 174 117 97 149 171 100 151
<ENTER></pre>
 
=={{header|Perl}}==
{{trans|Perl 6Raku}}
<syntaxhighlight lang ="perl">my $a =package Automaton->new(30, 1, map 0, 1 .. 100);{
sub new {
my $class = shift;
my $rule = [ reverse split //, sprintf "%08b", shift ];
return bless { rule => $rule, cells => [ @_ ] }, $class;
}
sub next {
my $this = shift;
my @previous = @{$this->{cells}};
$this->{cells} = [
@{$this->{rule}}[
map {
4*$previous[($_ - 1) % @previous]
+ 2*$previous[$_]
+ $previous[($_ + 1) % @previous]
} 0 .. @previous - 1
]
];
return $this;
}
use overload
q{""} => sub {
my $this = shift;
join '', map { $_ ? '#' : ' ' } @{$this->{cells}}
};
}
 
my $a = Automaton->new(30, 1, map 0, 1 .. 100);
 
for my $n (1 .. 10) {
Line 184 ⟶ 719:
}
print $sum, $n == 10 ? "\n" : " ";
}</langsyntaxhighlight>
{{out}}
<pre>220 197 147 174 117 97 149 171 240 241</pre>
 
=={{header|Perl 6Phix}}==
Making the minimum possible changes to [[Elementary_cellular_automaton#Phix]], output matches C, D, Go, J, Kotlin, Racket, and zkl,
<lang perl6>my Automaton $a .= new: :rule(30), :cells( 1, 0 xx 100 );
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.
say :2[$a++.cells[0] xx 8] xx 10;</lang>
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #000080;font-style:italic;">--string s = ".........#.........", --(original)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"...............................#"</span><span style="color: #0000FF;">&</span>
<span style="color: #008000;">"................................"</span><span style="color: #0000FF;">,</span>
<span style="color: #000080;font-style:italic;">--string s = "#"&repeat('.',100), -- [2]</span>
<span style="color: #000000;">t</span><span style="color: #0000FF;">=</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"........"</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">rule</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">30</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rule</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)?</span><span style="color: #008000;">'#'</span><span style="color: #0000FF;">:</span><span style="color: #008000;">'.'</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">rule</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rule</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">80</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">w</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">w</span><span style="color: #0000FF;">*</span><span style="color: #000000;">2</span> <span style="color: #0000FF;">+</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">32</span><span style="color: #0000FF;">]=</span><span style="color: #008000;">'#'</span><span style="color: #0000FF;">)</span>
<span style="color: #000080;font-style:italic;">-- w = w*2 + (s[1]='#') -- [2]</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">&=</span><span style="color: #000000;">w</span> <span style="color: #000000;">w</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">l</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #000000;">l</span><span style="color: #0000FF;">:</span><span style="color: #000000;">j</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)]=</span><span style="color: #008000;">'#'</span><span style="color: #0000FF;">)*</span><span style="color: #000000;">4</span>
<span style="color: #0000FF;">+</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">]=</span><span style="color: #008000;">'#'</span><span style="color: #0000FF;">)*</span><span style="color: #000000;">2</span>
<span style="color: #0000FF;">+</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">l</span><span style="color: #0000FF;">?</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:</span><span style="color: #000000;">j</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)]=</span><span style="color: #008000;">'#'</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span>
<span style="color: #000000;">t</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">t</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
<pre>220 197 147 174 117 97 149 171 240 241</pre>
{220,197,147,174,117,97,149,171,100,151}
</pre>
{{out}}
with the changes marked [2]
<pre>
{220,197,147,174,117,97,149,171,240,241}
</pre>
 
=={{header|Python}}==
===Python: With zero padded ends===
<langsyntaxhighlight lang="python">from elementary_cellular_automaton import eca, eca_wrap
 
def rule30bytes(lencells=100):
Line 206 ⟶ 775:
 
if __name__ == '__main__':
print([b for i,b in zip(range(10), rule30bytes())])</langsyntaxhighlight>
 
{{out}}
Line 213 ⟶ 782:
 
===Python: With wrapping of end cells===
<langsyntaxhighlight lang="python">def rule30bytes(lencells=100):
cells = '1' + '0' * (lencells - 1)
gen = eca_wrap(cells, 30)
while True:
yield int(''.join(next(gen)[0] for i in range(8)), 2))</langsyntaxhighlight>
 
{{out}}
Line 226 ⟶ 795:
Implementation of [[Elementary cellular automaton]] is saved in "Elementary_cellular_automata.rkt"
 
<langsyntaxhighlight lang="racket">#lang racket
;; below is the code from the parent task
(require "Elementary_cellular_automata.rkt")
Line 265 ⟶ 834:
(number->string (C30-rand-64 256) 16)
(number->string (C30-rand-64 256) 16)
(number->string (C30-rand-64 256) 16))</langsyntaxhighlight>
 
{{out}}
Line 274 ⟶ 843:
"6d85153a987dad6f013bc6159a41bf95b9d9b14af87733e17c702a3dc9052172"
"fc6fd302f5ea8f2fba6f476cfe9d090dc877dbd558e5afba49044d05b14d258"</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>class Automaton {
has $.rule;
has @.cells handles <AT-POS>;
has @.code = $!rule.fmt('%08b').flip.comb».Int;
method gist { "|{ @!cells.map({+$_ ?? '#' !! ' '}).join }|" }
method succ {
self.new: :$!rule, :@!code, :cells(
@!code[
4 «*« @!cells.rotate(-1)
»+« 2 «*« @!cells
»+« @!cells.rotate(1)
]
)
}
}
 
my Automaton $a .= new: :rule(30), :cells( flat 1, 0 xx 100 );
 
say :2[$a++[0] xx 8] xx 10;</syntaxhighlight>
{{out}}
<pre>220 197 147 174 117 97 149 171 240 241</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">size = 100
eca = ElemCellAutomat.new("1"+"0"*(size-1), 30)
eca.take(80).map{|line| line[0]}.each_slice(8){|bin| p bin.join.to_i(2)}</langsyntaxhighlight>
{{out}}
<pre>
Line 291 ⟶ 886:
240
241
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">
//Assuming the code from the Elementary cellular automaton task is in the namespace.
fn main() {
struct WolfGen(ElementaryCA);
impl WolfGen {
fn new() -> WolfGen {
let (_, ca) = ElementaryCA::new(30);
WolfGen(ca)
}
fn next(&mut self) -> u8 {
let mut out = 0;
for i in 0..8 {
out |= ((1 & self.0.next())<<i)as u8;
}
out
}
}
let mut gen = WolfGen::new();
for _ in 0..10 {
print!("{} ", gen.next());
}
}
</syntaxhighlight>
{{out}}
<pre>
157 209 228 58 87 195 212 106 147 244
</pre>
 
=={{header|Scheme}}==
<langsyntaxhighlight lang="scheme">
; uses SRFI-1 library http://srfi.schemers.org/srfi-1/srfi-1.html
 
Line 314 ⟶ 938:
 
(random-r30 10)
</syntaxhighlight>
</lang>
 
{{out}}
Line 320 ⟶ 944:
<pre>
(220 197 147 174 117 97 149 171 240 241)
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">var auto = Automaton(30, [1] + 100.of(0));
 
10.times {
var sum = 0;
8.times {
sum = (2*sum + auto.cells[0]);
auto.next;
};
say sum;
};</syntaxhighlight>
{{out}}
<pre>
220
197
147
174
117
97
149
171
240
241
</pre>
 
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<langsyntaxhighlight lang="tcl">oo::class create RandomGenerator {
superclass ElementaryAutomaton
variable s
Line 340 ⟶ 989:
return [scan [join $bits ""] %b]
}
}</langsyntaxhighlight>
Demonstrating:
<langsyntaxhighlight lang="tcl">set rng [RandomGenerator new 31]
for {set r {}} {[llength $r]<10} {} {
lappend r [$rng rand]
}
puts [join $r ,]</langsyntaxhighlight>
{{out}}
220,197,147,174,241,126,135,130,143,234
Note that as the number of state bits is increased (the parameter to the constructor), the sequence tends to a limit of <math>220,</math> <math>197,</math> <math>147,</math> <math>174,</math> <math>117,</math> <math>97,</math> <math>149,</math> <math>171,</math> <math>240,</math> <math>241,</math> <math>\ldots</math> and that deviations from this are due to interactions between the state modification “wavefront” as the automaton wraps round.
 
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-big}}
As Wren cannot deal accurately with 64-bit unsigned integers and bit-wise operations thereon, we need to use BigInt here.
<syntaxhighlight lang="wren">import "./big" for BigInt
 
var n = 64
 
var pow2 = Fn.new { |x| BigInt.one << x }
 
var evolve = Fn.new { |state, rule|
for (p in 0..9) {
var b = BigInt.zero
for (q in 7..0) {
var st = state.copy()
b = b | ((st & 1) << q)
state = BigInt.zero
for (i in 0...n) {
var t1 = (i > 0) ? st >> (i-1) : st >> 63
var t2 = (i == 0) ? st << 1 : (i == 1) ? st << 63 : st << (n+1-i)
var t3 = (t1 | t2) & 7
if ((pow2.call(t3) & rule) != BigInt.zero) state = state | pow2.call(i)
}
}
System.write(" %(b)")
}
System.print()
}
 
evolve.call(BigInt.one, 30)</syntaxhighlight>
 
{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
</pre>
 
=={{header|zkl}}==
No attempts at extra credit and not fast.
<langsyntaxhighlight lang="zkl">fcn rule(n){ n=n.toString(2); "00000000"[n.len() - 8,*] + n }
fcn applyRule(rule,cells){
cells=String(cells[-1],cells,cells[0]); // wrap edges
Line 366 ⟶ 1,051:
}
n
}</langsyntaxhighlight>
Note that "var" in a function is "static" in C, ie function local variables, initialized once.
<langsyntaxhighlight lang="zkl">do(10){ rand30().print(","); }</langsyntaxhighlight>
{{out}}
<pre>220,197,147,174,117,97,149,171,100,151,</pre>
Jjuanhdez
2,122

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/243285...362119"