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.

The rules of evolution are then encoded with eight bits indicating the outcome of each of the eight possibilities 111, 110, 101, 100, 011, 010, 001 and 000 in this order. Thus for instance the rule 13 means that a state is updated to 1 only in the cases 011, 010 and 000, since 13 in binary is 0b00001101.

 

 

The space state should ''wrap'': this means that the left-most cell should be considered as the right neighbor of the right-most cell, and reciprocally.

 

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

 

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

{{trans|Ruby}}

def run(start_str, rule, times) do

IO.puts "rule : #{rule}"

defp rule_pattern(rule) do

end

IO.puts String.replace(str, "0", ".") |> String.replace("1", "#")

str2 = String.last(str) <> str <> String.first(str)

each(next_str, patterns, times-1)

end

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

str = pad <> "1" <> pad

 

{{out}}

</pre>

 

 

 

 

=={{header|Go}}==

 

import (

output()

}

{{out}}

<pre>

# #### ### ## #

</pre>

 

=={{header|Perl}}==

use warnings;

 

for (1..40) {

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

{{out}}

<pre>| # |

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

 

 

{{out}}

 

 

 

 

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

 

 

 

(define (evolve ls r)

n))

 

{{out}}

 

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

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

 

=={{header|Sidef}}==

{{trans|Perl}}

 

method init {

}

 

method next {

previous.range.map { |i|

4*previous[i-1 % len] +

previous[i+1 % len]

}

}

 

method to_s {

}

}

 

 

 

(size/2).times {

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