Elementary cellular automaton/Infinite length: Difference between revisions

 

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

 

'''Preliminaries'''

def lpad($len; $fill): tostring | ($len - length) as $l | ($fill * $l)[:$l] + .;

 

# input: an array, e.g. as produced by [7|stream]

# output: the corresponding binary string

'''The Cellular Automaton'''

# giving the rows produced by the eca defined by

# $cells (a string) and $rule (an integer)

| .c = ([range(1; .c|length - 1) as $i | $neighbours2next[.c[$i-1:$i+2] ]] | join(""));

[$i, .c] ) ;

'''The Task'''

def main($lines):

(90, 30) as $rule

| ($line|lpad(3)) + " " * ($lines - $line) + (.[1] | tr("01"; ".#") )));

 

{{out}}

As for [[#Python|Python]].

=={{header|Julia}}==

{{trans|Python}}

notcell(cell) = (cell == '1') ? '0' : '1'

rulebits = reverse(string(rule, base = 2, pad = 8))

 

testinfcells(25)

<pre>

Rule: 90 (01011010)

=={{header|Kotlin}}==

{{trans|C++}}

 

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

evolve(35, 90)

println()

 

{{out}}

=={{header|Mathematica}} / {{header|Wolfram Language}}==

An infinite background is built-in the language:

 

=={{header|Nim}}==

{{trans|Kotlin}}

 

 

 

 

 

{{out}}

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

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

Based heavily on the code from the [[One-dimensional_cellular_automata#Raku|One-dimensional cellular automata]] task. Example uses rule 90 (Sierpinski triangle).

 

has $.rule;

has @.cells;

 

# then calculate the other infinite number of rows, (may take a while)

{{out}}

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

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var addNoCells = Fn.new { |s|

 

evolve.call(35, 90)

 

{{out}}

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