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

* [http://natureofcode.com/book/chapter-7-cellular-automata Cellular automata (natureofcode.com)]

<br><br>

 

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

---(output snipped)---

</pre>

 

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

using System;

using System.Collections;

}

}

{{out}}

<pre>

50: .##.#...#.#...#.##.

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

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

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

</pre>

 

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

 

'

' Elementary One-Dimensional Cellular Automaton

RETURN result%

ENDFUNC

 

=={{header|Go}}==

 

import (

output()

}

{{out}}

<pre>

 

===Array-based solution ===

 

 

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

 

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

 

 

 

 

 

 

</pre>

 

=={{header|Kotlin}}==

{{trans|C++}}

 

import java.util.BitSet

evolve(state)

}

 

{{out}}

</pre>

 

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

use warnings;

 

for (1..40) {

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

{{out}}

<pre>| # |

| # # # # # # # # |

| # # # # # # # # # # # # # # # # |</pre>

 

=={{header|Phix}}==

String-based solution

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>

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

</pre>

 

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

23: #.#.#.#.#.#.#.#.................#.#.#.#.#.#.#.# ##.####..##.#..###.#...#..####...#..#.##.###### #.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#

24: #...............#...............#...............# ##..#...###..####...##.#####...#.#####.#..#.....# #.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.# </pre>

 

=={{header|Racket}}==

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

#fx(522495)

0</pre>

 

=={{header|Ruby}}==

include Enumerable

 

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

{{out}}

<pre>

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

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

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

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

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