Photo CD Demo 1/Demo.bin/cellsim/v2_5/doc/sample.fls

Text File | 1990-02-26 | 10.2 KB | 253 lines

Among the example files provided are the following:

     nodes.64x:    An almost empty 2D array with five isolated cells in state 1.

     cross.64x:    An otherwise empty array with an X of cells in state 1.

     ckrbrd.64x: A checkerboard pattern of 0's and 1's.

     block.64x:    A block of 3's in the middle of an otherwise empty array.

     learn1.64x, learn2.64x:
             A pair of `before' and `after' images, respectively, which
        when used with the Learn command will teach an expanding
        rings rule.

     mod3.v8, mod5.v8, mod8.v8:
        Transition rules for modular addition.

     heart.v8:    Transition rule for excitable medium with three states:
             0 = quiescent, 1 = excited, 2 = refractory (unexcitable).
             Any excitation in the neighborhood of a quiescent cell will
             make it excited. Single refractory cells surrounded by
        quiescent cells become excited (not normal for excitable
        media, but leads to more interesting dynamics).

     loop.v8, loop.64x:
             Transition rule and starting image for Langton's
        self-reproducing loop.

     codd.v8, coddemit.64x:
             Transition rule for Codd's universal automaton, and the image
        of a periodic emitter using this rule.

     tunnel.v8: Toffoli and Margolus' second-order TIME-TUNNEL rule.  Works
        with either states 0-3 or 4-7.  Inverting the image causes
        time reversal. Works well with block.64x, above.

     life.m2, life.m4:
        Conway's Game of Life (no CA would be complete without it).
        The 4-state version shows the current state in plane 0 and an
        echo of the previous state in plane 1.

     ggun.64x:  Glider gun for use with Life rules above.

     brain.m4:    Toffoli and Margolus' BRIAN'S-BRAIN rule. Works well with a
        random initial configuration.

     mod8.l8:    Transition rule for modular addition in one dimension.

     firing.l8, firing.64, firing.128, firing.256:
        Transition rule for Balzer's 8-state firing squad solution
        (where the soldiers are state 1, the general is 2, and the
        firing state is 0) plus starting images for various size 1D
        arrays.

     bbm.M4:    The "billiard-ball model" described in Toffoli and
        Margolus' book.

     bbm.128x:    An image for the bbm rule to demonstrate diffusion in a jar.
        You should let this run for at least 400 steps or so;
        it takes about that long for things to become fairly
        homogeneous.

     bbm2.128x: Another image for the bbm rule, which demonstrates circular
        wave propagation.

     dla.M8:    Diffusion-limited aggregation.  Particles move around until
        they are next to the growing seed, at which point they
        "stick" to it.  Note that plane-2 runs the bbm rule and
        acts as a random-number source to drive the particles on
        plane 0 in a random-walk.  You should use the "plane"
        operations to set the display-plane mask to 3, otherwise
        it is difficult to see what is going on with all the noise.
        Or, instead of using the display plane-mask, you can use
        the "dla.cmap" colormap that is supplied in the standard
        Cmap directory.

     dla.64x:    Sample image for demonstrating the dla rule.  There are
        some particles on plane 0 which will diffuse, and a
        single-cell seed in the middle which will grow.

     rainbow.cmap:
        An alternate colormap for 8-state machines.

     rainbow256.cmap:
        A 256-state rainbow-like colormap; this is a great cmap
        to use with the "heat" rules.

     colors.64x:
        An array divided into 16 regions, one of each state 0 - F.
        Useful for checking the effect of a new colormap, or for
        checking the bitplane editing functions.

     heat.m256.sun[34].o
        An interesting computed-function rule to watch.  This rule
        finds the average value of the cells in the neighborhood,
        and moves the current cell toward that average by a specified
        amount, and then adding an increment.  Run this starting
        with the "heat.64x" image, using the "rainbow256.cmap"
        colormap, and let it run for at least a few hundred steps.
        This rule uses both parm1 and parm2; parm1 is the so-called
        "heat constant", and parm2 is the increment that is added
        to each cell after it moves toward the local average.
        See the "heat.m256.c" file in the "Rule_src" directory for
        more info; a good setting is parm1 = 100, parm2 = 2, which
        is the default when you load in the rule.

     heat.l256r2.sun[34].o
        Similar to the heat.m256.o rule, but for the linear
        neighborhood of radius 2.  Start with a random configuration;
        a good setting is parm1 = 100, parm2 = 2.  Noticee the effect
        of using slightly different values for parm2.

     cycle.v256.sun[34].o, cycle.m256.sun[34].o
        The "cyclic food-chain" rule described in A.K. Dewdney's
        "Computer Recreations" column, from the August '89 issue
        of Scientific American.  This type of rule was discovered
        by David Griffeath, and was also mentioned in section 9.6
        of _Cellular Automata Machines_ by Toffoli and Margolus.
        parm1 describes how many states there are; the default
        for the v256 version of the rule is 8, and the default for
        the m256 rule is 16.  Try starting with a random configuration,
        each cell having a value between 0 and "parm-1".  (You must
        use the "general" menu-item under the "Random" menu to do
        this).  See the Scientific American article for more info
        about this rule.

     griffeath.v8
        A lookup-table version of Griffeath's CA.  This was sent
        in by Eiiti Wada.  It runs much faster than the
        computed-function versions, although you can't change the
        number of states.

     vants.M4
        Chris Langton's "virtual ants", as described in his article
        "Studying Artificial Life with Cellular Automata" (Physica 22D,
        1986).  The vants are on plane 0, and the "background" is on
        plane 1.  Since the Margolus neighborhood is used, if you try
        to put a pattern on plane 1, but overlap the edge of a
        margolus block, bad things will happen (vants will not be
        conserved).  So you should simply start with one or many vants
        on plane 0.
        A vant turns left when it hits black, and turns right when
        it hits blue.  In either case, it flips the background color
        of the square it is on.
        A "vant glider" was discovered by Dave Hiebeler and Chris
        Langton; a copy of it is in "vantglider.64x".  Note that you
        must be on an even time-step when you load the image, because
        of the way the Margolus origin alternates.  You should click
        on the "zero" button in the control panel before loading the
        image, to set the current time to an even value, namely 0.

     vantloop.64x
        An image which contains 2 vants, which will move around each
        other, leaving a "loop" trail behind.  They will continue
        to move around, expanding the loop.  Again, you must be on
        an even time-step when you load this image.


     antivants.M8
        A modification of the vants rule, which also has "antivants"
        which behave the opposite way (turn right on black, left on
        green) as normal vants (left on black, right on green).
        Vants are on plane 0, antivants on plane 1, and the
        background on plane 2.  Again, you shouldn't try to set
        a background pattern unless you are very familiar with how
        the Margolus neighborhood operates, and be sure each 2x2 block
        has only 1 background color within it.
        A small random cluster of vants and antivants on a black
        background often does interesting things, but usually needs
        a larger grid (256x256) so there is room for things to
        develop.
        There are many possible configurations of vants and antivants
        that act as gliders, with different periods and different
        directions of motion.  You can usually find them without too
        much trouble by starting with a small random patch of vants
        and antivants.  One image that was generated by doing this
        is "antivglider.128x".  It contains a glider made of a
        vant and antivant, as well as a vant/antivant team that is
        constructing a growing "arm".  Make sure you're on an even
        time-step before you load in the image.
        (We have some more examples of various gliders on the CAM-6,
        which will hopefully be included in the next release of
        Cellsim.  We lack hardware to transfer them from CAM to Sun
        right now).

     ramp.256x
        A "ramp" of values.  The left-most column has cells all of
        value 0, the next column of value 1, and so on over to the
        right-most column, whose cells are all of value 255.
        This is useful for looking at 256-entry colormaps.

  The source-code used to generate some of these rules is in the "Rule_src"
directory.

  See the "Rule_src" directory for source-code to some of the rules, and
the Makefile which you will need to generate your own rules.

  We would like to strongly encourage Cellsim users to submit any interesting
rules they discover, and any images that accompany them.  We would like to
collect a user-contributed library of rules/images to be distributed with
later versions of Cellsim.  Images and lookup-tables are most easily submitted
by compressing them, running them through "uuencode", and then mailing them.
Rule source-code can just be directly mailed.

  Send new rules or comments to either Chris Langton ([e-mail]) or
Dave Hiebeler ([e-mail]).


/*
 *
 * Cellsim copyright 1989, 1990 by Chris Langton and Dave Hiebeler
 * ([e-mail], [e-mail])
 *
 * This package may be freely distributed, as long as you don't:
 * - remove this notice
 * - try to make money by doing so
 * - prevent others from copying it freely
 * - distribute modified versions without clearly documenting your changes
 *   and notifying us
 *
 * Please contact either of the authors listed above if you have questions
 * or feel an exception to any of the above restrictions is in order.
 *
 * If you make changes to the code, or have suggestions for changes,
 * let us know!  If we use your suggestion, you will receive full credit
 * of course.
 */

/*****
 * Cellsim history:
 *
 * Cellsim was originally written on Apollo workstations by Chris Langton.
 *
 * Sun versions:
 *
 * - version 1.0
 *   by C. Ferenbaugh and C. Langton
 *   released 09/02/88
 *
 * - version 1.5
 *   by Dave Hiebeler and C. Langton  May - June 1989
 *   released 07/03/89
 *
 * - version 2.0
 *   by Dave Hiebeler and C. Langton  July - August 1989
 *   never officially released (unofficially released 09/08/89)
 *
 * - version 2.5
 *   by Dave Hiebeler and C. Langton  September '89 - February 1990
 *   released 02/26/90
 *****/