Wireworld: Difference between revisions

{{omit from|GUISS}}

[[wp:Wireworld|Wireworld]] is a cellular automaton with some similarities to [[Conway's Game of Life]].

 

and is much simpler to program for.

 

each of which can be in one of four states.

All cell transitions happen simultaneously.

 

The cell transition rules are this:

|-

! Input State

|}

 

<pre>

tH.........

While text-only implementations of this task are possible, mapping cells to pixels is advisable if you wish to be able to display large designs. The logic is not significantly more complex.

<br><br>

 

=={{header|Ada}}==

 

procedure Test_Wireworld is

Wireworld (Oscillator);

end loop;

The solution assumes that the border of the board is empty. When transition is performed these cells are not changed. Automation transition is an in-place operation that allocates memory for to keep one row of the board size.

<pre style="height:30ex;overflow:scroll">

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - missing transput function "printf" and non standard associate}}

Wireworld implementation.

CO

print ( world2string(ww) );

ww := next gen(ww)

{{out}}

<pre style="height:45ex;overflow:scroll">

{{works with|AutoHotkey_L}}

{{libheader|GDIP}}

#NoEnv

SetBatchLines, -1

Exit:

Gdip_Shutdown(pToken)

 

=={{header|AutoIt}}==

 

$ww = ""

$ww &= "tH........." & @CR

WEnd

EndFunc ;==>Wireworld

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

[[Image:wireworld_bbc.gif|right]]

DIM P&(Size%-1,Size%-1), Q&(Size%-1,Size%-1)

SWAP P&(), Q&()

WAIT 50

 

=={{header|C}}==

Compile with <code>-D_POSIX_C_SOURCE=199309L</code> or greater to make <code>nanosleep</code> visible in <code><time.h></code>.

 

#define ANIMATE_VT100_POSIX

#include <stdio.h>

 

return 0;

 

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

{{libheader|POSIX}} (for usleep)

 

#include <set>

#include <map>

}

std::cout << std::endl;

 

 

=={{header|Common Lisp}}==

 

(destructuring-bind (rows cols) (array-dimensions wireworld)

(loop for off-row from (max 0 (1- row)) to (min (1- rows) (1+ row)) sum

" ... "

". . "

{{out}}

<pre style="height:30ex;overflow:scroll">CL-USER> (wireworld-show-gens (make-rosetta-wireworld) 12)

 

=={{header|D}}==

 

void wireworldStep(char[][] W1, char[][] W2) pure nothrow @safe @nogc {

swap(world, world2);

}

{{out}}

<pre>

. ....

.. </pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

@empty " "

@head "H"

"""

 

{{out}}

</pre>

 

=={{header|Forth}}==

8 constant h

 

: gen ['] newrow foreachrow age ;

 

 

{{out}}

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

end do

end subroutine Nextgen

{{out}}

<pre style="height:30ex;overflow:scroll">Generation 0

. .

tH...</pre>

 

=={{header|Go}}==

Text output. Press Enter to compute and display successive generations.

 

import (

}

}

 

=={{header|Haskell}}==

import Control.Monad

import Control.Arrow

noH = length $ filter (=='H') $ concat xs

 

Example executed in GHCi:

". ....",

" .. "

]

 

{{out}}

<pre style="height:30ex;overflow:scroll">

This simulation starts in single step mode and can be switched to run uninterrupted. The window can be saved at any point in single step mode.

This uses 1 pixel per cell so this animation looks tiny. Also the orientation has been flipped.

 

$define EDGE -1

}

}

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

tH........

. .

. .

Ht.. .....

A 'boarding' verb board and the next cell state verb nwS:

 

nwS=: 3 : 0

if. ('.'=e)*. e.&1 2 +/'H'=,y do. 'H' return. end.

' t..' {~ ' Ht.' i. e

The 'most' powerful part is contained in the following iterating sentence, namely the dyad cut ;. [http://www.jsoftware.com/help/dictionary/d331.htm ]. In this way verb nwS can work on all the 3x3 matrices containing each cell surrounded by its 8 relevant neighbors.

Example run:

<pre style="height:30ex;overflow:scroll">

Note also that a graphical presentation can be achieved using viewmat. For example:

 

 

(This example opens 10 windows, one for each generation.)

=={{header|Java}}==

See: [[Wireworld/Java]]

 

=={{header|jq}}==

* For speed, the simulation uses the exploded string (an array).

* The ASCII values of the symbols used to display the state are hardcoded.

 

def cols: split("\n")[0]|length + 1; # allow for the newline

$world | evolve($i; $w) as $next

| if .[$i] == $next then . else .[$i] = $next end )

'''Animation'''

def cls: "\u001b[2J";

 

 

# Input: a string representing the initial state

'''Examples''':

"+-----------+\n" +

"|tH.........|\n" +

" . .... \n" +

" .. \n" +

'''Illustration 1''':

'''Illustration 2''':

 

To run: jq -n -r -f wireworld.rc

 

=={{header|Liberty BASIC}}==

[[File:AnimWW.gif]]

WindowWidth = 840

WindowHeight = 600

timer 1000, [tmr]

wait

=={{header|Logo}}==

{{Works with|MSWlogo}}

(The wireworld given in the file must be bounded by spaces for the program to work. Also it is notable that the program takes the width as the longest of the lines.)

Make "speed 60/:speed

wireworldread :filename

if (mditem (list :y-1 :x-1) :field)=:thing [Make "neighbours :neighbours+1]

ifelse OR :neighbours=1 :neighbours=2 [op "true] [op "false]

 

ArrayPad[PadRight[Characters /@ StringSplit["tH.........

. .

3, {{a_, b_, c_}, {d_, 3, e_}, {f_, g_, h_}} :>

Switch[Count[{a, b, c, d, e, f, g, h}, 1], 1, 1, 2, 1, _, 3]},

 

=={{header|Nim}}==

{{trans|C}}

 

var world, world2 = """

|Ht.. ......|

+-----------+"""

let h = world.splitLines.len

let w = world.splitLines[0].len

 

 

proc next(o: var string, s: string, w: int) =

 

world2.next(world, w)

 

=={{header|OCaml}}==

 

" ......tH ";

" . ...... ";

aux n

in

 

=={{header|Oz}}==

Includes a simple animation, using a text widget.

Rules =

[rule(& & )

{Field set(text:{ShowArena Gi})}

{Delay 500}

 

=={{header|PARI/GP}}==

wireworldStep(M)={

my(sz=matsize(M),t);

)

};

 

=={{header|Perl}}==

Read the initial World from stdin and print 10 steps to stdout

 

for (1 .. 10) {

}

@f = (@a,[]);

Input:

<pre>tH.........

</pre>

 

 

=={{header|PHP}}==

 

$desc = 'tH.........

. .

draw_world($world);

};

 

=={{header|PicoLisp}}==

This example uses 'grid' from "lib/simul.l", which maintains a two-dimensional

structure.

 

(let

(for This Col

(=: val (: next)) ) )

{{out}}

<pre> +---+---+---+---+---+---+---+---+---+---+---+

=={{header|PureBasic}}==

===Standalone version===

#Empty

#Electron_head

Data.i 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

Data.i 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

===Load from external source, graphical presentations===

CompilerError "The file handling in this small program is only in ASCII."

CompilerEndIf

EndIf

Until Event=#PB_Event_CloseWindow

Example of data file to load

<pre>; Save as "WireWorld.txt"

=={{header|Python}}==

 

Wireworld implementation.

'''

print ( ("\n%3i " % gen) + '=' * (ww.w-4) + '\n' )

print ( world2string(ww) )

 

{{out}}

=={{header|Racket}}==

 

#lang racket

(require 2htdp/universe)

 

(run-wire-world #:initial-state initial-list)

 

=={{header|REXX}}==

parse arg iFID . '(' generations rows cols bare head tail wire clearScreen reps

generations = p(generations 100 ) /*number generations that are allowed. */

rows = p(rows 3 ) /*the number of cell rows. */

cols = p(cols 3 ) /* " " " " columns. */

clearScreen = p(clearScreen 0 ) /*1 means to clear the screen. */

head = pickChar(head 'H' ) /*pick the character for the head. */

reps = p(reps 2 ) /*stop program if there are 2 repeats.*/

/* [↓] read the input file. */

/*watch cells evolve, 4 possible states*/

do r=1 for rows /*process each of the rows. */

select /*determine the type of cell. */

otherwise nop

end /*select*/

end /*c*/

end /*r*/

end /*life*/

/*stop watching the universe (or life).*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

call showRows /*show rows in proper order.*/

Programming note: &nbsp; the &nbsp; '''hood''' &nbsp; subroutine (above) could be optimized for speed by setting some short-circuit values &nbsp; <code>('''r-1''', '''c-1''', '''r+1''', and '''c+1''') </code> &nbsp; and using those values in the subsequent expressions.

 

(Cycle &nbsp; '''0''' &nbsp; (zero) &nbsp; is essentially a copy of the input file.)

<pre style="height:60ex">

t.tH ......

═══════════════════════════════════════════════════════════════════════════════════════13

</pre>

 

=={{header|Ruby}}==

See: [[Wireworld/Ruby]]

 

=={{header|Sidef}}==

{{trans|Perl}}

 

10.times {

rr << (

given(c) {

when('H') { 't' }

when('t') { '.' }

default { c }

}

)

}

}

}

 

...

. .

 

=={{header|Standard ML}}==

 

type world = char vector vector

" ... ",

". . ",

 

=={{header|Tcl}}==

to construct a two dimensional 3 by 3 sliding window.

The rule function maps a pair (cell,neighborhood) to a new cell.

 

rule = case~&l\~&l {`H: `t!, `t: `.!,`.: @r ==`H*~; {'H','HH'}?</`H! `.!}

neighborhoods = ~&thth3hthhttPCPthPTPTX**K7S+ swin3**+ swin3@hNSPiCihNCT+ --<0>*+ 0-*

 

test program:

 

<

#show+

 

{{out}}

<pre style="height:15ex;overflow:scroll">

......... ...

..

</pre>

 

=={{header|XPL0}}==

[[File:WireXPL0.gif|right]]

char New(53,40), Old(53,40);

 

until KeyHit; \keystroke terminates program

SetVid(3); \restore normal text mode