Elementary cellular automaton: Difference between revisions

{{trans|Nim}}

V LINES = SIZE I/ 2

V RULE = 90

L 1..LINES

show(state)

{{out}}

=={{header|Action!}}==

DEFINE MAX_COL="319"

DEFINE MAX_ROW="191"

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Elementary_cellular_automaton.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{works with|Ada 2012}}

procedure Elementary_Cellular_Automaton is

Generations => 25);

end Elementary_Cellular_Automaton;

{{Output}}

<pre>Rule 90 :

=={{header|ALGOL 68}}==

COMMENT returns the next state from state using rule; s must be at least 2 characters long and consist of # and - only COMMENT

PROC next state = ( STRING state, INT rule )STRING:

test( "---------#---------", 60 );

test( "---------#---------", 90 )

{{out}}

<pre>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

rule := 90

output := "Rule: " rule

result .= val = 1 ? "#" : "."

return result

{{Output}}

<pre>Rule: 90

=={{header|C}}==

64 cells, edges are cyclic.

#include <limits.h>

return 0;

{{out}}

<pre>

=={{header|C sharp|C#}}==

using System;

using System.Collections;

}

}

{{out}}

<pre>

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

#include <stdio.h>

}

return 0;

{{out}}

<pre> # |

=={{header|Ceylon}}==

shared Byte number;

automaton.evolve();

}

{{out}}

<pre>Rule #90

=={{header|Common Lisp}}==

(labels ((next-gen (cells)

(mapcar #'new-cell

do (pretty-print cells))))

{{Out}}

=={{header|D}}==

{{trans|Python}}

enum mod = (in int n, in int m) pure nothrow @safe @nogc => ((n % m) + m) % m;

eca.popFront;

}

{{out}}

<pre>Rules: [90, 30, 122]

Pictures of the (nice) generated colored bit-maps : The Escher like [http://www.echolalie.org/echolisp/images/automaton-1.png (task 90 5)] and the fractal like [http://www.echolalie.org/echolisp/images/automaton-2.png (task 22 1)]

(lib 'types) ;; int32 vectors

(lib 'plot)

→ #( #( 0 0 0) #( 0 -5052980 0) #( 0 -5052980 -5052980))

=={{header|Elixir}}==

{{works with|Elixir|1.3}}

{{trans|Ruby}}

def run(start_str, rule, times) do

IO.puts "rule : #{rule}"

pad = String.duplicate("0", 14)

str = pad <> "1" <> pad

{{out}}

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

===The Function===

// Elementary Cellular Automaton . Nigel Galloway: July 31st., 2019

let eca N=

let N=Array.init 8 (fun n->(N>>>n)%2)

Seq.unfold(fun G->Some(G,[|yield Array.last G; yield! G; yield Array.head G|]|>Array.windowed 3|>Array.map(fun n->N.[n.[2]+2*n.[1]+4*n.[0]])))

===The Task===

eca 90 [|0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0|] |> Seq.take 80 |> Seq.iter(fun n->Array.iter(fun n->printf "%s" (if n=0 then " " else "@"))n; printfn "")

{{out}}

<pre>

@ @

</pre>

eca 110 [|0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;1|] |> Seq.take 80 |> Seq.iter(fun n->Array.iter(fun n->printf "%s" (if n=0 then " " else "@"))n; printfn "")

{{out}}

<pre>

=={{header|Factor}}==

math.combinatorics sequences sequences.extras ;

[ dup show-state next-state ] times 2drop ;

{{out}}

<pre>

{{works with|gforth|0.7.3}}

<br>

\ Elementary cellular automaton

bye

{{out}}

* rule 110 [https://commons.wikimedia.org/wiki/File:Rule-110.png]

=={{header|FreeBASIC}}==

#define NCELLS 400

#define border 16

end if

key = ucase(inkey)

=={{header|Fōrmulæ}}==

=={{header|Furor}}==

argc 4 < { ."Usage: " 0 argv sprint SPACE 1 argv sprint SPACE ."rule size\n"

."The \"rule\" and \"size\" are numbers.\n"

// =================================================

{{out}}

<pre>

=={{header|GFA Basic}}==

'

' Elementary One-Dimensional Cellular Automaton

RETURN result%

ENDFUNC

=={{header|Go}}==

import (

output()

}

{{out}}

<pre>

Straight-forward implementation of CA on a cyclic domain, using immutable arrays:

step rule a = listArray (l,r) res

[rule (a!(r-1)) (a!r) (a!l) ]

The following gives decoding of the CA rule and prepares the initial CA state:

initial n = listArray (0,n-1) . center . padRight n

where

padRight n lst = take n $ lst ++ repeat 0

Finally the IO stuff:

where result = fmap display . elems <$> runCA rule init

display 0 = ' '

{{Out}}

The cyclic CA domain is represented by an infinite ''zipper list''. First we provide the datatype, the viewer and constructor:

import Control.Comonad

-- zero cycle length ensures that elements of the empty cycle will never be accessed

fromList lst = let x:::r = Inf.cycle lst

In order to run the CA on the domain we make it an instance of <code>Comonad</code> class. Running the CA turns to be just an iterative comonadic ''extension'' of the rule:

extract (Cycle _ _ x _) = x

duplicate x@(Cycle n _ _ _) = fromList $ take n $ iterate shift x

step rule (Cycle _ l x (r:::_)) = rule l x r

Rule definition and I/O routine is the same as in Array-based solution:

initial n lst = fromList $ center $ padRight n lst

where result = fmap display . view <$> runCA rule init

display 0 = ' '

See also [[Elementary cellular automaton/Infinite length#Haskell]]

We'll define a state transition mechanism, and then rely on the language for iteration and display:

' *'{~90 next^:(i.9) 0 0 0 0 0 0 1 0 0 0 0 0

*

* *

* * * *

Or, we can view this on a larger scale, graphically:

=={{header|Java}}==

{{works with|Java|8}}

import java.awt.event.ActionEvent;

import javax.swing.*;

});

}

[[File:ca java.png|900px]]

=={{header|JavaScript}}==

const dead = '.';

}

{{out}}

<pre>

'''Helper functions'''

def states:

{"111": 1, "110": 2, "101": 3, "100": 4, "011": 5, "010": 6, "001": 7, "000": 8};

| .[1:] # remove the leading 0

| join("")

'''Main function'''

def automaton(rule; steps):

| gsub("0"; ".") # pretty print

| gsub("1"; "#")

=={{header|Julia}}==

const lines = 10

const start = ".........#........."

end

end

Using Rule 90:

.........#.........

=={{header|Kotlin}}==

{{trans|C++}}

import java.util.BitSet

evolve(state)

}

{{out}}

=={{header|Lua}}==

state = "..............................#..............................",

bstr = { [0]="...", "..#", ".#.", ".##", "#..", "#.#", "##.", "###" },

print(string.format("%-66s%-66s%-66s%-61s", ca[1].state, ca[2].state, ca[3].state, ca[4].state))

for j = 1, 4 do ca[j]:evolve() end

{{out}}

<pre style="font-size:50%">..............................#.............................. ..............................#.............................. ..............................#.............................. ..............................#..............................

Mathematica provides built-in functions for cellular automata. For example visualizing the first 100 rows of rule 30 on an 8-bit grid with a single initial cell:

=={{header|MATLAB}}==

init(n + 1, :) = 0;

for k = 1 : n

init(k + 1, :) = bitget(rule, 1 + filter2([4 2 1], init(k, :)));

{{out}}

ans =

*

* * * * * * * *

* * * * * * * *

=={{header|Nim}}==

{{trans|Kotlin}}

const

for _ in 1..Lines:

show(state)

{{out}}

=={{header|Octave}}==

E=200;

idx=round(E/2);

endfor

imagesc(reshape(z,E,E)'); % Medland map

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

for (1..40) {

print "|$a|\n"; $a->next;

{{out}}

<pre>| # |

=={{header|Phix}}==

String-based solution

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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: #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>

Output matches that of D and Python:wrap for rule = 90, 30, 122 (if you edit/run 3 times)

=={{header|PicoLisp}}==

(extract

'((A B)

(cellular

".........#........."

{{out}}

<pre>

=={{header|Prolog}}==

initial([0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]).

writ(0) :- write('.').

=={{header|Python}}==

:''You can deal with the limit conditions (what happens on the borders of the space) in any way you please.''

lencells = len(cells)

c = "0" + cells + "0" # Zero pad the ends

i = data[0]

cells = data[1:]

{{out}}

===Python: wrap===

The ends of the cells wrap-around.

lencells = len(cells)

rulebits = '{0:08b}'.format(rule)

cells = data[1:]

print('%2i: %s' % (i, ' '.join(cells).replace('0', '.').replace('1', '#')))

{{out}}

Pad and extend with inverse of end cells on each iteration.

return '0' if c == '1' else '1'

i = data[0]

cells = ['%s%s%s' % (' '*(lines - i), c, ' '*(lines - i)) for c in data[1:]]

{{out}}

=={{header|Quackery}}==

( Rule (R), the Size of the space (S) and the Current )

( state (C). make-ca sets this up from a string indicating )

say "Rule 30, 50 generations:" cr cr

{{out}}

unmodified for [[Elementary cellular automaton/Infinite length]].

(require racket/fixnum)

(provide usable-bits/fixnum usable-bits/fixnum-1 CA-next-generation

(show-automaton v #:step step #:sig-bits 19)

(newline)

{{out}}

Using the <tt>Automaton</tt> class defined at [[One-dimensional_cellular_automata#Raku]]:

has $.rule;

has @.cells;

:cells(flat @padding, 1, @padding);

{{out}}

=={{header|Ruby}}==

include Enumerable

eca = ElemCellAutomat.new('1'.center(39, "0"), 18, true)

{{out}}

<pre>

=={{header|Rust}}==

fn main() {

struct ElementaryCA {

}

}

{{out}}

<pre>

=={{header|Scala}}==

===Java Swing Interoperability===

import java.awt.event.ActionEvent

})

=={{header|Scheme}}==

(define (evolve ls r)

n))

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

method init {

print "|#{auto}|\n"

auto.next

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

oo::class create ElementaryAutomaton {

puts [string map "0 . 1 #" [join $s ""]]

}

Demonstrating:

ElementaryAutomaton create rule90 90

rule90 run 20

puts "\nRule 122:"

{{out}}

<pre>

{{works with|Bourne Again SHell}}

{{works with|Korn Shell}}

local chars=(. '#') cell

for cell; do

automaton "$@"

{{Out}}

<pre> 0: ................#...............

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

var SIZE = 32

show.call(state)

evolve.call(state)

{{out}}

=={{header|zkl}}==

fcn applyRule(rule,cells){

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

(cells.len() - 2).pump(String,'wrap(n){ rule[7 - cells[n,3].toInt(2)] })

r90.println(" rule 90");

{{out}}

<pre>