Elementary cellular automaton: Difference between revisions

 

An '''[[wp:elementary cellular automaton|elementary cellular automaton]]''' is a one-dimensional [[wp:cellular automaton|cellular automaton]] where there are two possible states (labeled 0 and 1) and the rule to determine the state of a cell in the next generation depends only on the current state of the cell and its two immediate neighbors. Those three values can be encoded with three bits.

This task is basically a generalization of [[one-dimensional cellular automata]].

 

 

;See also

{{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]

48: #.....#.....#.....# #...##.####....##.. ####...........####

49: ##...#.#...#.#...## ##.##..#...#..##.## ...##.........##...</pre>

 

=={{header|EchoLisp}}==

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>

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

</pre>

 

=={{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>

</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}}==

end

end

 

 

</pre>

 

=={{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}}

* * * * * * * *

* * * * * * * * * * * * * * * *

</pre>

 

=={{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>