Rosetta Code

Elementary cellular automaton/Random number generator: Difference between revisions

Page Discussion

Elementary cellular automaton/Random number generator (view source)

Revision as of 10:12, 27 August 2022

845 bytes added ,  1 year ago
m
sntax highlighting fixup automation
m (sntax highlighting fixup automation)
Line 17:
{{trans|Nim}}
 
<langsyntaxhighlight lang="11l">V n = 64
 
F pow2(x)
Line 36:
print()
 
evolve(1, 30)</langsyntaxhighlight>
 
{{out}}
Line 45:
=={{header|C}}==
64-bits array size, cyclic borders.
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <limits.h>
 
Line 75:
evolve(1, 30);
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 220 197 147 174 117 97 149 171 100 151</pre>
Line 81:
=={{header|C++}}==
We'll re-write the code of the parent task here.
<langsyntaxhighlight lang="cpp">#include <bitset>
#include <stdio.h>
 
Line 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 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 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]
Line 184:
=={{header|F_Sharp|F#}}==
This task uses [[Elementary cellular automaton#The_Function]]
<langsyntaxhighlight 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>
</lang>
{{out}}
<pre>
Line 195:
=={{header|Go}}==
{{trans|C}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 240:
func main() {
evolve(1, 30)
}</langsyntaxhighlight>
 
{{out}}
Line 251:
Assume the comonadic solution given at [[Elementary cellular automaton#Haskell]] is packed in a module <code>CellularAutomata</code>
 
<langsyntaxhighlight Haskelllang="haskell">import CellularAutomata (fromList, rule, runCA)
import Control.Comonad
import Data.List (unfoldr)
Line 264:
(fromList (1 : replicate size 0))
 
fromBits = foldl ((+) . (2 *)) 0</langsyntaxhighlight>
 
{{Out}}
Line 272:
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:
 
<langsyntaxhighlight Haskelllang="haskell">import System.Random
 
instance RandomGen (Cycle Int) where
Line 278:
let x = c =>> step (rule 30)
in (fromBits (view x), x)
split = (,) <*> (fromList . reverse . view)</langsyntaxhighlight>
 
<pre>λ> let r30 = fromList [1,0,1,0,1,0,1,0,1,0,1,0,1] :: Cycle Int
Line 300:
=={{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 312:
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 322:
=={{header|Julia}}==
{{trans|C, Go}}
<langsyntaxhighlight lang="julia">function evolve(state, rule, N=64)
B(x) = UInt64(1) << x
for p in 0:9
Line 344:
 
evolve(1, 30)
</langsyntaxhighlight>{{out}}
<pre>
220 197 147 174 117 97 149 171 100 151
Line 351:
=={{header|Kotlin}}==
{{trans|C}}
<langsyntaxhighlight lang="scala">// version 1.1.51
 
const val N = 64
Line 377:
fun main(args: Array<String>) {
evolve(1, 30)
}</langsyntaxhighlight>
 
{{out}}
Line 385:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">FromDigits[#, 2] & /@ Partition[Flatten[CellularAutomaton[30, {{1}, 0}, {200, 0}]], 8]</langsyntaxhighlight>
{{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>
Line 391:
=={{header|Nim}}==
{{trans|Kotlin}}
<langsyntaxhighlight Nimlang="nim">const N = 64
 
template pow2(x: uint): uint = 1u shl x
Line 409:
echo ""
 
evolve(1, 30)</langsyntaxhighlight>
 
{{out}}
Line 417:
{{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
<langsyntaxhighlight lang="pascal">Program Rule30;
//http://en.wikipedia.org/wiki/Next_State_Rule_30;
//http://mathworld.wolfram.com/Rule30.html
Line 556:
Task;
write(' <ENTER> ');readln;
end.</langsyntaxhighlight>
{{out}}
<pre>//compiled 64-Bit
Line 578:
=={{header|Perl}}==
{{trans|Raku}}
<langsyntaxhighlight lang="perl">package Automaton {
sub new {
my $class = shift;
Line 614:
}
print $sum, $n == 10 ? "\n" : " ";
}</langsyntaxhighlight>
{{out}}
<pre>220 197 147 174 117 97 149 171 240 241</pre>
Line 622:
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.
<!--<langsyntaxhighlight Phixlang="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>
Line 648:
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 661:
=={{header|Python}}==
===Python: With zero padded ends===
<langsyntaxhighlight lang="python">from elementary_cellular_automaton import eca, eca_wrap
 
def rule30bytes(lencells=100):
Line 670:
 
if __name__ == '__main__':
print([b for i,b in zip(range(10), rule30bytes())])</langsyntaxhighlight>
 
{{out}}
Line 677:
 
===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 690:
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 729:
(number->string (C30-rand-64 256) 16)
(number->string (C30-rand-64 256) 16)
(number->string (C30-rand-64 256) 16))</langsyntaxhighlight>
 
{{out}}
Line 741:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" perl6line>class Automaton {
has $.rule;
has @.cells;
Line 761:
my Automaton $a .= new: :rule(30), :cells( flat 1, 0 xx 100 );
 
say :2[$a++.cells[0] xx 8] xx 10;</langsyntaxhighlight>
{{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 784:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">
//Assuming the code from the Elementary cellular automaton task is in the namespace.
fn main() {
Line 806:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 813:
 
=={{header|Scheme}}==
<langsyntaxhighlight lang="scheme">
; uses SRFI-1 library http://srfi.schemers.org/srfi-1/srfi-1.html
 
Line 833:
 
(random-r30 10)
</syntaxhighlight>
</lang>
 
{{out}}
Line 842:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var auto = Automaton(30, [1] + 100.of(0));
 
10.times {
Line 851:
};
say sum;
};</langsyntaxhighlight>
{{out}}
<pre>
Line 868:
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<langsyntaxhighlight lang="tcl">oo::class create RandomGenerator {
superclass ElementaryAutomaton
variable s
Line 884:
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
Line 899:
{{libheader|Wren-big}}
As Wren cannot deal accurately with 64-bit unsigned integers and bit-wise operations thereon, we need to use BigInt here.
<langsyntaxhighlight lang="ecmascript">import "/big" for BigInt
 
var n = 64
Line 924:
}
 
evolve.call(BigInt.one, 30)</langsyntaxhighlight>
 
{{out}}
Line 933:
=={{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 946:
}
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>
Thundergnat
10,327

edits

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