Wireworld: Difference between revisions

 

The cell transition rules are this:

|-

! Input State

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

 

shared Cell output({Cell*} neighbors) =>

}

}

 

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

import extensions;

import cellular;

const string sample =

" tH......

. ......

...Ht...";

const string conductorLabel = ".";

const string headLabel = "H";

const string tailLabel = "t";

const string emptyLabel = " ";

const int empty = 0;

const int conductor = 1;

const int electronHead = 2;

const int electronTail = 3;

wireWorldRuleSet = new RuleSet

{

{

int cell := s.at(x, y);

cell =>

conductor

if (number == 1 || number == 2)

{

}

else

{

}

}

electronHead

{

}

electronTail

{

}

}

}

};

sealed class Model

{

Space theSpace;

constructor load(string stateString, int maxX, int maxY)

{

theSpace := IntMatrixSpace.allocate(maxX, maxY, RuleSet

{

{

if (x < strings.Length)

{

{

retVal := empty

}

})

}

run()

{

theSpace.update(wireWorldRuleSet)

}

print()

{

int columns := theSpace.Columns;

int rows := theSpace.Rows;

int i := 0;

int j := 0;

{

j := 0;

while (j < columns)

{

var label := emptyLabel;

int cell := theSpace.at(i, j);

cell =>

conductor { label := conductorLabel }

electronHead { label := headLabel }

electronTail { label := tailLabel };

console.write(label);

j := j + 1

};

i := i + 1;

console.writeLine()

}

}

public program()

{

Model model := Model.load(sample,10,30);

{

console.printLineFormatted("Iteration {0}",i);

model.print().run()

}

{{out}}

<pre>

. ......

Ht......

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

Only visual output. Not an all-out simulator, but has some functions not on by default.

/*

Wireworld first declares constants and then reads a wireworld from a textfile.

ds_grid_destroy(gridid);

ds_list_destroy(listid);

Now the step event

//Step event

/*

}

}

Now the draw event

//Draw event

/*

}

draw_set_color(c_black);

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

<input type='file' accept='text/plain' onchange='openFile( event )' />

<br /></body></html></pre>

var ctx, sizeW, sizeH, scl = 10, map, tmp;

function getNeighbour( i, j ) {

simulate();

}

 

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

h, w = size(b)

[b[x,y] for x in i-1:i+1, y in j-1:j+1 if (0 < x <= h && 0 < y <= w)]

mat .= mat2

end

Starting Wireworld board:

 

.H

</pre>

 

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

[[File:AnimWW.gif]]

WindowWidth = 840

WindowHeight = 600

timer 1000, [tmr]

wait

 

=={{header|Lua}}==

If ran using [[L%C3%96VE]], it will animate the simulation on a window. Otherwise it will print the first 10 steps on the console.

local map = {{'t', 'H', '.', '.', '.', '.', '.', '.', '.', '.', '.'},

{'.', ' ', ' ', ' ', '.'},

end

end

 

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

H t H . . . . . . .

</pre>

 

=={{header|Phix}}==

 

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

if iFID=='' then iFID= "WIREWORLD.TXT" /*should default input file be used? */

wire = pickChar(wire . ) /* " " " " " wire. */

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

#reps= 0; $.= bare; gens= abs(generations) /*at start, universe is new and barren.*/

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

end /*r*/

!.= 0; signal on halt /*initial state of cells; handle halt.*/

/*watch cells evolve, 4 possible states*/

do life=1 for gens; @.= bare /*perform for the number of generations*/

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

halt: if life-1\==gens then say 'The ───Wireworld─── program was interrupted by user.'

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

$: parse arg _row,_col; return $._row._col==head

if reps\==0 & #reps<=reps then return /*so far, so good, no reps.*/

say '"Wireworld" repeated itself' reps "times, the program is stopping."

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.

 

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

"Wireworld" repeated itself 2 times, the program is stopping.

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

 

=={{header|Yabasic}}==

backcolor 0,0,0

clear window

wait .5

loop