Elementary cellular automaton/Infinite length: Difference between revisions

 

The purpose of this task is to create a version of an [[Elementary cellular automaton]] whose number of cells is only limited by the memory size of the computer.

 

More complex methods can be imagined, provided it is possible to somehow encode the infinite sections. But for this task we will stick to this simple version.

 

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

#include <iostream>

#include <iomanip>

return 0;

}

{{out}}

<pre>

=={{header|D}}==

{{trans|Python}}

std.algorithm;

alias R = replicate;

}

}

The output is the same as the Python entry.

 

{{works with|Elixir|1.3}}

{{trans|Ruby}}

defmodule Elementary_cellular_automaton do

def infinite(cell, rule, times) do

IO.puts "\nRule : #{rule}"

Elementary_cellular_automaton.infinite("1", rule, 25)

 

{{out}}

=={{header|Go}}==

{{trans|C++}}

 

import (

fmt.Println()

}

 

{{out}}

First we provide the datatype, the viewer and constructor:

 

 

import Control.Comonad

fromList [] = fromList [0]

fromList (x:xs) = let zeros = Inf.repeat 0

 

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 (Cells _ x _) = x

duplicate x = Cells (rewind left x) x (rewind right x)

 

runCA rule = iterate (=>> step)

 

Following is the rule definition and I/O routine:

 

 

displayCA n w rule init = mapM_ putStrLn $ take n result

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

display 0 = ' '

 

{{Out}}

Implementation:

 

trim=: |.@(}.~ ] i. 1-{.)^:2

 

In other words, a wrapped version of the [[Elementary_cellular_automaton#J|original implementation]].

example use:

 

*

* *

* * * *

* * * * * * * *

 

Looks like a [[Sierpinski_triangle|Sierpinski triangle]]

 

=={{header|Julia}}==

{{trans|Python}}

ret = String[]

for i in 1:n

push!(ret, cells)

cells = join([neighbors2next[cells[i:i+2]] for i in 1:length(cells)-2], "")

end

function testinfcells(lines::Integer)

for rule in [90, 30]

s = ecainfinite("1", rule, lines)

for i in 1:lines

 

testinfcells(25)

<pre>

1: #

 

1: #

</pre>

 

=={{header|Kotlin}}==

{{trans|C++}}

 

fun evolve(l: Int, rule: Int) {

evolve(35, 90)

println()

 

{{out}}

..*...*...........................................................*...*..

</pre>

 

=={{header|Perl}}==

The edges of a pattern is implicitly repeating. The code will try to lineup output by padding up to 40 spaces to the left, but since the cells keep expanding, that has to end somewhere.

my ($rule, $pattern) = @_;

my $offset = 0;

}

 

{{out}}

<pre>

-13| ..#.......#.......#.......#..

---(infinite more lines snipped)---

</pre>

 

=={{header|Phix}}==

Uses 0-expansion either side

{{out}}

<pre>

Infinite generator but only print 25 lines of each rule.

 

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

 

print('\nRule: %i' % rule)

for i, c in zip(range(lines), eca_infinite('1', rule)):

 

{{out}}

Uses solution to [[Elementary cellular automaton]] saved in file "Elementary_cellular_automata.rkt"

 

; below is the code from the parent task

(require "Elementary_cellular_automata.rkt")

(show-automaton v #:step step #:push-right o)

(newline)

 

{{out}}

#fx(536879104 0 33554944)

0</pre>

 

=={{header|Ruby}}==

{{trans|Python}}

c.tr('01','10')

end

end

end

The output is the same as the Python entry.

 

=={{header|Sidef}}==

{{trans|Perl}}

var offset = 0

var (l='', r='')

}

 

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

oo::class create InfiniteElementaryAutomaton {

$rule run 25

$rule destroy

{{out}}

<pre>

….##..#...###..####...##.#####...#.#####.#..#.....#.…

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

</pre>

 

=={{header|zkl}}==

{{trans|D}}

foreach rule in (T(90,30)){

println("\nRule: ", rule);

C=[1..C.len()-2].pump(String,'wrap(n){ neighs2next[C[n-1,3]] });

}

{{out}}

<pre>