%  tutorial.tex
%  Copyright (C) 1992  J Dana Eckart
%
%  This program is free software; you can redistribute it and/or modify
%  it under the terms of the GNU General Public License as published by
%  the Free Software Foundation; either version 1, or (at your option)
%  any later version.
%
%  This program is distributed in the hope that it will be useful,
%  but WITHOUT ANY WARRANTY; without even the implied warranty of
%  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%  GNU General Public License for more details.
%
%  You should have received a copy of the GNU General Public License
%  along with CELLULAR-2.0; see the file COPYING.  If not, write to the 
%  Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

\documentstyle[12pt]{article}

% Setup the desired page style.
\pagestyle{plain}
\setlength{\textwidth}{6.5in}
\setlength{\textheight}{9.15in}
\setlength{\oddsidemargin}{0mm}
\setlength{\evensidemargin}{0mm}
\setlength{\topmargin}{-0.3in}
\setlength{\headheight}{0mm}
\setlength{\headsep}{0mm}

\setlength{\columnsep}{5mm}

% Setup the desired paragraph style.
\setlength{\parindent}{0mm}
\setlength{\parskip}{3mm}
\begin{document}

% A new command to define a constant tabbing distance for code examples.
\newcommand{\tab}{\hspace{5mm}}

\title{A {\em Cellular} Automata Simulation System:\\Version 2.0}
\author{J Dana Eckart\\
        Radford University}
\date{}
\maketitle

\section{Introduction}
With the growing popularity of cellular automata in both recreation
\cite{life}\cite{wireworld}\cite{fluids}\cite{crystals} 
and the modeling of physical 
systems\cite{toffoli}\cite{Wolf-Gladrow}\cite{Chen}\cite{Lavallee}\cite{Lim},
the need for an easy--to--use system for cellular automata programming
is greater than ever.  {\em Cellular} is a system designed and implemented
by the author to meet these needs.  The system consists of: a programming
language, {\em Cellang 2.0}\footnote{
	        Pronounced cell ' ang.
        },
and associated compiler, {\tt cellc};
an ``abstract'' virtual machine\footnote{
		The construction of an actual machine embodying the
		pe--scam architecture is under development.\cite{pe-scam}
	}
for execution, {\tt pe-scam}; and a viewer, {\tt cellview}.
Compiled {\em Cellang 2.0} programs can be run
with input provided at any specified time during the execution.  The
results of an execution can either be viewed directly or output as
a stream of cell locations and values.  This stream of output
data can then be fed into {\tt cellview} for viewing, or it may
be passed through a filter that compiles statistics, massages the
data, or merely acts as a valve to control the flow of data from the
cellular automaton program to the viewer.  This simple UNIX\footnote{
                UNIX is a registered trademark of AT\&T.
        }
toolkit view of the simulation process provides greater control
than systems which combine the language and viewer (i.e.
cellsim\cite{cellsim} and CAM--6\cite{toffoli}).  {\em Cellang 2.0}
provides greater flexibility, particularly in the formation of
neighborhoods, than does {\em Cal} (part of the {\em Scamper} 
system)\cite{Scamper}.  And although the {\em SLANG}\cite{SLANG} system
supports probablistic possibilities, {\em Cellang 2.0} is a far
simpler language for constructing deterministic cellular automata.

\section{The Language}

Programs written in {\em Cellang 2.0} have two main components, a cell
description and a set of statements.  The cell description determines
how many dimensions there are, what field(s) each cell
contains, and the range of assignable values associated with each field.  
Statements occur in only two varieties:
assignment and if.  The assignment
statement is unusual in that it provides conditional assignment;
the if statement is of a conventional nature.

There is only one primitive data type in {\em Cellang 2.0}, integer. 
Variables are
declared by their first usage which is usually as the left hand side of an
assignment statement.  Conditional expressions follow the
rules of {\em C}\cite{harbison},
thus 0 values correspond to false and non--0 values indicate
true.  The arithmetic and logical operators available are: --, +, *, /,
\% (remainder), ! (logical not), \& (logical and), $|$ (logical or), 
=, !=, $<=$ and $>=$.  The field values of cells 
neighboring the 
current cell may be accessed by placing their relative position within square
brackets ([ ]), followed by an optional dot (.) and field name.

This version (2.0) is an incompatible upgrade to the previous 
version (1.0).\cite{cellang 1.0}
The differences are primarily:
\begin{itemize}

\item
{\em Cellang 2.0} does NOT permit the specification of dimension index ranges
(whereas {\em Cellang 1.0} did);

\item
{\em Cellang 2.0} does NOT permit the use of dimension names to determine a
cell's exact location within the universe (as did {\em Cellang 1.0});

\item
{\em Cellang 2.0} DOES allow multiple fields to be associated with each cell
of the universe (unlike {\em Cellang 1.0} which had only one field per cell);

\item
{\em Cellang 2.0} REQUIRES a range of legal values be given for all cell fields 
(whereas this was optional in {\em Cellang 1.0}).

\end{itemize}

\begin{figure}[t]
\begin{center}
\begin{verbatim}
2 dimensions of 0..1

sum := [0, 1] + [1, 1] + [1, 0] + [-1, 1] + [-1, 0] + 
       [-1, -1] + [0, -1] + [1, -1]

cell := 1 when (sum = 2 & cell = 1) | sum = 3
     := 0 otherwise
\end{verbatim}
\end{center}
\caption{The game of Life}
\label{simple life}
\end{figure}

The game of Life, popularized by Gardener\cite{life},
demonstrates many of the features of {\em Cellang 2.0}.  
Figure~\ref{simple life}
shows the this problem.  Note
that the universe of cells is 2--dimensional each having either a 0 or
1 value.  Comments begin
with a sharp (\#) and continue to the end of that line.  The predefined variable
{\tt cell} is special as it refers to the current cell of the universe under 
consideration.
Assignment to the variable {\tt cell} is the only way in which the value 
of the current cell (or one of its fields)
can be altered.  Furthermore, the new value of {\tt cell} doesn't take effect
until the beginning of the next cycle.  Notice that the standard Moore 
neighborhood used by the
game of Life must be given by relative indexing.\footnote{
                Relative indexing specifies a cell relative to the
                current cell.  Thus the relative index ``[-1, 1]''
                refers to the bordering northwest cell.
        }
While relative indexing may seem cumbersome,
it provides great flexibility.  The only practical restriction on relative 
indices is that they be integer constants.

Because there are no language specific limits on the size of relative indices,
it is possible to explore a wide range of neighborhoods.
Neighborhoods which use field values {\em n} cells away are possible 
for any value of integer value {\em n}.
In addition, there is no restriction that neighborhoods
be symmetrical or have any other special topographical properties.

An additional predefined variable,
{\tt time}, can only appear within expressions.
Thus a program can not change {\tt time}, but {\tt time} can be used to 
influence
computation.  The initial value of {\tt time} is 0 and it is incremented by 1 
each time all the cells of the universe have been updated.
This feature allows neighborhoods which
are time dependent.  Figure~\ref{time dependent life} demonstrates this
possibility.  Similarly it is also possible to have cell field values change
with dependence upon time.
The time dependent neighborhoods can be used to represent both
hybrid neighborhoods
or in situations where the physical system behaves
according to different rules/neighborhoods as it ages.

\begin{figure}[t]
\begin{center}
\begin{verbatim}
2 dimensions of 0..1

if time % 2 = 0 then
   sum := [0, 1] + [1, 0] + [-1, 0] + [0, -1]
else
   sum := [1, 1] + [-1, 1] + [-1, -1] + [1, -1]
end

cell := 1 when (sum = 2 | sum = 3) & cell = 1
     := 1 when sum = 3 & cell = 0
     := 0 otherwise
\end{verbatim}
\end{center}
\caption{An alternate game of life with a time dependent (hybrid) neighborhood}
\label{time dependent life}
\end{figure}

\begin{figure}[t]
\begin{center}
\begin{verbatim}
2 dimensions of
        x, y of 0..255
end

cell.x := ([1, 0].y + [0, 1].y + [-1, 0].y + [0, -1].y) % 256 
                when time % 2

cell.y := ([-1, 1].x + [1, 1].x + [-1, -1].x + [1, -1].x) % 256 
                when (time + 1) % 2
\end{verbatim}
\end{center}
\caption{An example program with multi--field cells.}
\label{multiple cell fields}
\end{figure}

{\em Cellang 2.0} programs may also contain more than a single field
per cell.  The program given in Figure~\ref{multiple cell fields} shows 
a program with 3 fields per cell.
Note that the dot notation familiar from many other languages for use
with records/structures, is used here to determine which of several
cell fields is being denoted.  If, on the other hand, the field name is 
not present, then all fields of the cell are used in
assignment and for tests of equality and inequality.

Finally, both the input and output of {\em Cellang 2.0} programs
allow the user to manipulate cellular automata data in ways that many
systems do not permit.  Both input and output are of identical form,
thus allowing automata to be chained together.  Both
input and output are given as a sequence of time blocks.  A time block
begins with a time (a non--negative integer value) followed by zero or more
cell location and value pairs.  When multiple time blocks are given,
successive times must be strictly greater than all previous times.
An example set of time blocks for a 2--dimensional automata is given in
Figure~\ref{time blocks}.  It specifies that although
all the cells of the universe have a default value of 0 at time
0, the cell at absolute location 3, 3 will have a value of 1.  Furthermore,
it specifies that at the beginning of time 100 (before any cells have been
updated), the cell at absolute location 24, 56 has its first field set to 0,
the cell at absolute location 50, 50 has its first field set to 5 and it second
field set to 6, and the cell at location 2, 32 has its third field set to 3.
This cell value input process continues for
as many time blocks as are in the input.  The output of a {\em Cellang 2.0}
program has the same form and can thus appear as input to another
automata.  If each cell has several values which must be set, then the
multiple values are separated by commas and are assigned in the order in
which they were declared in the associated {\em Cellang 2.0} program.  When
only some of the possible field values are given, then the values
are assigned in order until no more are available, the unspecified cell fields 
thus retain their previous values.
\begin{figure}[t]
\begin{center}
\begin{verbatim}
                             0
                             [3, 3] = 1
                             100
                             [24, 56] = 0
                             [50, 50] = 5, 6
                             [2, 32] = , , 3
\end{verbatim}
\end{center}
\caption{An example input/output for a {\em Cellang 2.0} program}
\label{time blocks}
\end{figure}

\section{The Viewer}

The viewer, which is used to examine the cell values in a graphic manner, is
independent of the {\em Cellang 2.0} language and compiler.  The input
to the viewer is identical in form to the output (and thus the input)
of {\em Cellang 2.0} programs.  The current viewer allows the viewing of
a single field along contiguous portions of any two dimensions.
The values can be displayed as either characters
(via curses) or colored squares (via X--Windows).  A limited debugging
aid (available only with the X--Windows viewing option) also allows the numeric 
values of a neighborhood of cells (as opposed
to the color associated with this value) to be viewed.

The idea of separating the language (and thus the cellular automata
simulator) and the viewer allows
greater flexibility both in the viewing of data and in the creation of
cellular automata.  There is no restriction that
the input to the viewer be generated by a {\em Cellang 2.0} program, and it
is possible that programs of other sorts will be developed
to examine, gather and report statistics concerning the results of
{\em Cellang 2.0} programs.  ``Valve'' filters
could be inserted between the output generated by a {\em Cellang 2.0}
program and the input to the viewer.  Such a valve program could allow
the presentation speed to be tailored to the researcher's needs.
Since the output of {\em Cellang 2.0} programs are written
to the standard output, it can be piped directly
into the viewer with no need for intermediate storage files.  The
use of a tpipe filter would enable storage of all or part of the
produced cell values into a file.

\begin{figure}[t]
\begin{center}
\begin{verbatim}
                                     50
                                     +1
                                     100
                                     500!
\end{verbatim}
\end{center}
\caption{An example time file for reporting cell values}
\label{report times}
\end{figure}

\section{Compiling \& Viewing}

Suppose the {\em Cellang 2.0} program for the game of Life that appears in 
Figure~\ref{simple life} is in the file {\tt life}.
A compiled version of the code is obtained by doing {\tt cellc life}
which places the object code into a file called {\tt a.pe-scam}.
The object code is executed and displayed by the {\tt pe-scam} 
abstract machine via:
\begin{verbatim}
pe-scam -c a.pe-scam -r times -x11 -map life.colors < life.data
\end{verbatim}
where {\tt life.data} is a data file containing the 
initial configuration of live cells and
{\tt life.colors}
contains a suitable color map.
An optional parameter, {\tt -f},
is used to indicate which field (starting from 1 for the first field) to 
use as the value to display for the cells.
The {\tt -r} option indicates a file which contains information about
which generations to report cell values for.  

If the {\tt -r} option is not given
then the cell values which have changed will be reported for each generation.
A sample time file appears in Figure~\ref{report times}.  A time file is a list
of time indications given one per line.  A number indicates a 
time when the values should be
reported, while a ``+'' entry causes these values to be produced at the 
indicated time intervals.  Finally a ``!'' entry determines the time at
which the last set of values should be produced and the simulation stops.
Note that a time file need not contain a ``!'' entry.  In the example,
The first set of values (after time 0) is produced at time 50, then at each 
time thereafter until time 100 at which point no values are reported 
until time 500 and the simulation stops.

Alternatively, {\tt pe-scam} can just output the cell values which can be
filtered and/or viewed with {\tt cellview}.  An example of this style of
use is:
\begin{verbatim}
cat  life.data | pe-scam -r times -o |
                         cellview -x11 -map life.colors -dim 0..63,0..63
\end{verbatim}
Where the {\tt -o} option indicates that cell values be written to the
standard output.  The ``-c a.pe--scam'' has been left out, since the
the codefile is assumed to be ``a.pe-scam'' by default.
Note that now, however, the dimensions of the cell universe must be known.
By convention, {\tt pe-scam}'s cell universe begins numbering at 0 for
each dimension.  The size and number of dimensions is implementation
dependent (and can be configured at installation time in the current release
of the software).

\begin{figure}[t]
\begin{center}
\setlength{\unitlength}{3pt}
\begin{picture}(31, 31)(0, 0)
\normalsize

\put(0, 20){\framebox(10, 10){0}}
\put(10, 20){\framebox(10, 10){1}}
\put(10, 10){\framebox(10, 10){3}}
\put(0, 10){\framebox(10, 10){2}}

\put(11, 9){\dashbox(10, 10){}}
\put(21, 9){\dashbox(10, 10){2}}
\put(21, -1){\dashbox(10, 10){0}}
\put(11, -1){\dashbox(10, 10){1}}

\end{picture}
\end{center}
\caption{Margolus neighborhood}
\label{Margolus neighborhood}
\end{figure}

\begin{figure}[t]
\begin{center}
\begin{verbatim}
                             0 1 0 1 0 1 0 1 0 1
                             2 3 2 3 2 3 2 3 2 3
                             0 1 0 1 0 1 0 1 0 1
                             2 3 2 3 2 3 2 3 2 3
\end{verbatim}
\end{center}
\caption{The pattern of {\tt which} field values for the Margolus neighborhood}
\label{which Margolus}
\end{figure}

\section{Advanced Examples}
This section examines two example programs that demonstrate techniques for
generating the Margolus and hexagonal neighborhoods.  The Margolus
neighborhood will be used in the simulation of the diffusion of a 
gas,\footnote{
		The program is modeled closely on the version
		described by \cite{toffoli} on page 156.
	}
while the hexagonal neighborhood is used to calculate distance.

\begin{figure}[tbp]
\begin{center}
\footnotesize
\begin{verbatim}
2 dimensions of 
        which of 0..3
        rand  of 0..1
        gas   of 0..1
end

# Calculate the shared random value in the block of 4 cells.
random := cell.rand + [1, 0].rand + [1, -1].rand + [0, -1].rand
                when (cell.which = 0 & time%2 = 1) | (cell.which = 3 & time%2 = 0)

       := [-1, 0].rand + cell.rand + [0, -1].rand + [-1, -1].rand
                when (cell.which = 1 & time%2 = 1) | (cell.which = 2 & time%2 = 0)

       := [-1, 1].rand + [0, 1].rand + cell.rand + [-1, 0].rand
                when (cell.which = 3 & time%2 = 1) | (cell.which = 0 & time%2 = 0)

       := [0, 1].rand + [1, 1].rand + [1, 0].rand + cell.rand
                otherwise

# Alternate between the overlapping 4 cell blocks
if time%2 = 1 then
        if random%2 = 1 then
                # Clockwise rotation
                cell.gas := [0, -1].gas when cell.which = 0
                         := [-1, 0].gas when cell.which = 1
                         := [0, 1].gas when cell.which = 3
                         := [1, 0].gas when cell.which = 2
        else
                # Counter-clockwise rotation
                cell.gas := [1, 0].gas when cell.which = 0
                         := [0, -1].gas when cell.which = 1
                         := [-1, 0].gas when cell.which = 3
                         := [0, 1].gas when cell.which = 2
        end
else
        if random%2 = 1 then
                # Clockwise rotation
                cell.gas := [0, -1].gas when cell.which = 3
                         := [-1, 0].gas when cell.which = 2
                         := [0, 1].gas when cell.which = 0
                         := [1, 0].gas when cell.which = 1
        else
                # Counter-clockwise rotation
                cell.gas := [1, 0].gas when cell.which = 3
                         := [0, -1].gas when cell.which = 2
                         := [-1, 0].gas when cell.which = 0
                         := [0, 1].gas when cell.which = 1
        end
end

# Stir the random values, so that they keep changing.
cell.rand := ([1, 0].rand + [0, 1].rand + [-1, 0].rand + [0, -1].rand + cell.rand)%2
\end{verbatim}
\end{center}
\caption{Gas diffusion using a Margolus neighborhood}
\label{gas diffusion}
\end{figure}

\subsection{Margolus Neighborhood}
Gas diffusion can be simulated by implementing a random walk for each
particle/molecule of gas.
The random walk can be implemented by using non--overlapping
blocks of four cells (two on a side) which are offset at alternate times
(Margolus neighborhood) and having each block of cells randomly rotate their 
gas particles either clockwise or 
counter--clockwise.

To better understand the Margolus neighborhood, consider 
Figure~\ref{Margolus neighborhood}.  The four cell block with a solid
outline, and the other with the dashed outline, would be used at
alternate times.  At any particular time, however, the universe of cells 
is completely covered by a non--overlapping set of blocks.  To implement
a Margolus neighborhood in {\em Cellang 2.0} requires use of the {\tt
time} variable and some way of distinguishing between different blocks
of 4 cells.  The latter is accomplished by introducing a field, {\tt which},
that contains a value, 0 to 3, indicating the cells relative position in
the block.  A portion of the cell universe {\tt which} values
are shown in Figure~\ref{which Margolus}.

Now that the four cell block can be identified, a random number, common
to each cell in the block, must be generated.  This is done by having
each cell maintain a two value (0 or 1) {\tt rand} field.  By using {\tt time}
and the value of {\tt which} a random number, ``shared'' by each cell of the
block, can be calculated.  This random number is used to determine whether
the particles of gas, denoted by the value of the {\tt gas} fields,
are rotated clockwise or counter--clockwise.
To maintain an ever changing {\tt rand} field
for each cell, a new value is calculated using the Von Neumann neighborhood.
The {\em Cellang 2.0} program that implements gas diffusion is shown in 
Figure~\ref{gas diffusion}.  

\begin{figure}[tbp]
\begin{center}
\setlength{\unitlength}{4pt}
\begin{picture}(80, 60)(0, 0)

\multiput(10, 40)(20, 0){3}{\framebox(10, 20)
	{\shortstack{\,n\vspace{1ex}\\
			\, nw \  ne \vspace{6.2ex}\\
			\, sw \ \, se \vspace{1ex}\\
			s}}}
\multiput(10, 20)(20, 0){3}{\framebox(10, 20)
	{\shortstack{\,n\vspace{1ex}\\
			\, nw \  ne \vspace{6.2ex}\\
			\, sw \ \, se \vspace{1ex}\\
			s}}}
\multiput(10, 0)(20, 0){3}{\framebox(10, 20)
	{\shortstack{\,n\vspace{1ex}\\
			\, nw \  ne \vspace{6.2ex}\\
			\, sw \ \, se \vspace{1ex}\\
			s}}}

\multiput(0, 30)(20, 0){4}{\framebox(10, 20)
	{\shortstack{\,n\vspace{1ex}\\
			\, nw \  ne \vspace{6.2ex}\\
			\, sw \ \, se \vspace{1ex}\\
			s}}}
\multiput(0, 10)(20, 0){4}{\framebox(10, 20)
	{\shortstack{\,n\vspace{1ex}\\
			\, nw \  ne \vspace{6.2ex}\\
			\, sw \ \, se \vspace{1ex}\\
			s}}}

\end{picture}
\end{center}
\caption{A portion of a ``squeezed'' hexagonal universe}
\label{hexagons}
\end{figure}

\begin{figure}[tbp]
\begin{center}
\begin{verbatim}
                             0 1 0 1 0 1 0 1 0 1
                             1 0 1 0 1 0 1 0 1 0
                             0 1 0 1 0 1 0 1 0 1
                             1 0 1 0 1 0 1 0 1 0
\end{verbatim}
\end{center}
\caption{The pattern of {\tt which} field values for the hexagonal neighborhood}
\label{which hexagon}
\end{figure}

\subsection{Hexagonal Neighborhood}
Hexagonal neighborhoods exhibit properties desirable in the simulation
of many physical systems.  Fortunately, they are quite easy to build
in {\em Cellang 2.0}.  Simply imagine taking a hexagon and squeezing in
at the sides, yielding a two cell stack.  Doing this for the
entire cell universe is depicted in Figure~\ref{hexagons}.  The solid
lines show the boundary of the original hexagon.  The sides of the
hexagons have been labeled, clockwise from the top, n (north), ne (north
east), se (south east), s (south), sw (south west) and nw (north west).

In order to have the cells act as sets of 2 block stacks, a {\tt which}
field with the value pattern depicted in Figure~\ref{which hexagon} is
used.  The value 1 represents the top cell in a pair, while 0 denotes
the bottom cell.  Note that the top cell of a pair gets its s (south)
value by skipping over the bottom cell of the pair, likewise the bottom
cell skips over the top one for its n (north) value.  Thus each cell
pair agrees on the relative location of neighboring values.  Note that
this requires that initial (and subsequent) values for fields of cells
given as input must be coordinated with the assignment to the {\tt which}
fields, otherwise one or more cell pairs will have only one of the pair
getting the desired value.\footnote{
	In order to more accurately display (in X--Windows) the height--
	width ratio of the ``hexagons'', the option ``--s 5,3'' to
	{\tt pe-scam}/{\tt cellview} makes the displayed cells 5 pixels
	wide and 3 pixels high.
}

\begin{figure}[p]
\begin{center}
\begin{verbatim}
#                          north
#                          -----
#                    nw  /       \  ne
#                       /         \
#                       \         /
#                    sw  \       /  se
#                          -----
#                          south
#
2 dimensions of 
        which of 0..1
        dist  of 0..255
end

# Identification of the neighboring cells.
#
if cell.which = 0 then
        north := [0, 1]
        ne    := [1, 0]
        se    := [1, -1]
        south := [0, -2]
        sw    := [-1, -1]
        nw    := [-1, 0]
else
        north := [0, 2]
        ne    := [1, 1]
        se    := [1, 0]
        south := [0, -1]
        sw    := [-1, 0]
        nw    := [-1, 1]
end

min_dist := 255
min_dist := north.dist when north.dist < min_dist & north.dist > 0
min_dist := ne.dist    when ne.dist    < min_dist & ne.dist    > 0
min_dist := se.dist    when se.dist    < min_dist & se.dist    > 0
min_dist := south.dist when south.dist < min_dist & south.dist > 0
min_dist := sw.dist    when sw.dist    < min_dist & sw.dist    > 0
min_dist := nw.dist    when nw.dist    < min_dist & nw.dist    > 0

cell.dist := min_dist + 4 when cell.dist = 0 & min_dist < 255
\end{verbatim}
\end{center}
\caption{Calculating distance with hexagonal neighborhood}
\label{dist}
\end{figure}

\section{How To Find Out More}

The entire {\em Cellular} system is available from the author.  Please
send requests to either:
\begin{center}
J Dana Eckart\\
Box 6933\\
Computer Science Department\\
Radford University\\
Radford, VA \ 24142\\
\ \\
or\\
\ \\
dana@rucs.faculty.cs.runet.edu\\
\end{center}

\begin{thebibliography}{99}

\bibitem{Chen}
Chen, Shiyi, Hudong Chen and Gary D. Doolen,
``How the Lattice Gas Model for the Navier--Stokes Equation Improves When
a New Speed is Added'', {\em Complex Systems}, {\bf 3} (1989), 243--251.

\bibitem{wireworld}
Dewdney, A. K., ``The Cellular Automata Programs That Create Wireworld,
Rugworld and Other Diversions'',
{\em Scientific American}, {\bf 262}:1 (January 1990), 146--149.

\bibitem{crystals}
Dewdney, A. K., ``A Cellular Universe of Debris, Droplets, Defects and Demons'',
{\em Scientific American}, {\bf 261}:2 (August 1989), 102--105.

\bibitem{fluids}
Dewdney, A. K., ``The Hodgepodge Machine Makes Waves'',
{\em Scientific American}, {\bf 259}:2 (August 1988), 104--107.

\bibitem{pe-scam}
Eckart, J. Dana, ``A Parallel Extendible Scalable Cellular Automata Machine:
PE--SCAM'',
{\em Proceedings of the ACM $20^{th}$ Annual Computer Science Conference}, 
March 3--5, 1992, 467--472.

\bibitem{cellang 1.0}
Eckart, J. Dana, ``A {\em Cellular} Automata Simulation System'',
{\em SIGPLAN Notices}, {\bf 26}:8 (August 1991), 80--85.

\bibitem{life}
Gardner, Martin,
``The Fantastic Combinations of John Conway's New Solitaire Game of `Life','',
{\em Scientific American}, {\bf 223}:4 (April 1970), 120--123.

\bibitem{harbison}
Harbison, Samuel P. and Guy L. Steele Jr., {\em C: A Reference Manual},
Prentice Hall, Englewood Cliffs, New Jersey, 1991.

\bibitem{cellsim}
Langton, Chris and Dave Hiebeler, {\em Cellsim}, available by anonymous
ftp from isy.liu.se, Version 2.5.

\bibitem{Lavallee}
Lavalle\`e, Paul, Jean Pierre Boon and Alain Noullez,
``Lattice Boltzmann Equation for Laminar Boundary Flow'',
{\em Complex Systems}, {\bf 3} (1989), 317--330.

\bibitem{Lim}
Lim, Hwa A., ``Lattice Gas Automata of Fluid Dynamics for Unsteady Flow'',
{\em Complex Systems}, {\bf 2} (1988), 45--58.

\bibitem{Scamper}
Palmer, Ian J., {\em Scamper}, available by anonymous ftp from ftp.uu.net.

\bibitem{SLANG}
Sieburg, Hans B. and Oliver K. Clay, ``The Cellular Device Machine Development
System for Modeling Biology on the Computer'', {\em Complex Systems},
{\bf 5} (1991), 575--601.

\bibitem{toffoli}
Toffoli, Tommaso and Norman Margolus,
{\em Cellular Automata Machines: A New Environment for Modeling},
The MIT Press, Cambridge, Massachusetts, 1987.

\bibitem{Wolf-Gladrow}
Wolf--Gladrow, D. A., R. Nasilowski and A. Vogeler,
``Numerical Simulations of Fluid Dynamics with a Pair Interaction
Automaton in Two Dimensions'',
{\em Complex Systems}, {\bf 5} (1991), 89--100.

\end{thebibliography}

\end{document}
