# natj/CellularAutomata.jl

Cellular Automata simulation toolkit for Julia
Switch branches/tags
Nothing to show
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
examples
src
test
.gitignore

# Cellular Automata

A cellular automaton is a collection of "colored" cells on a grid of specified shape that evolves through a number of discrete time steps according to a set of rules based on the states of neighboring cells. The rules are then applied iteratively for as many time steps as desired.

mathworld.wolfram.com/CellularAutomaton

## Elementary CA

To generate an elementary cellular automaton, use

`ca = CellularAutomaton(rule, init, gen)`

where `rule` is the Wolfram code (integer), `init` is a vector containing the initial starting condition and `gen` is the number of generations to be computed. For a single starting cell in the middle just omit the `init` vector.

To generate 15 generations of elementary cellular automaton of rule 90 use

```using CellularAutomata

ca90 = CellularAutomaton(90, 16)```
``````                            #
# #
#   #
# # # #
#       #
# #     # #
#   #   #   #
# # # # # # # #
#               #
# #             # #
#   #           #   #
# # # #         # # # #
#       #       #       #
# #     # #     # #     # #
#   #   #   #   #   #   #   #
# # # # # # # # # # # # # # # #
``````

## Totalistic CA

For a more complex cellular automaton you can change the number of states `k` the cell can be and the radius `r` of neighbors that can influence the states. If `k` is changed to be larger than 2, a totalistic CA is computed where only the average value of all neighbors count. This can be done like this

`ca = CellularAutomaton(993, 15, k=3)`
``````                        X
XXX
X# #X
X     X
XXX   XXX
X# #X X# #X
X     #     X
XXX   ###   XXX
X# #X # X # X# #X
X      # X #      X
XXX    ## X ##    XXX
X# #X  #   X   #  X# #X
X     X### XXX ###X     X
XXX   X XX  # #  XX X   XXX
X# #X XX###X## ##X###XX X# #X
``````

## 2 dimensional CAs

Two dimensional cellular automaton (like Conway's Game of Life) can be created by

`ca = CA2d(B, S, init, gen)`

where `B` and `S` are vectors that have the numbers of neighboring cells that define when cell is born or survives, `init` (matrix) is the initial starting condition and `gen` is the number of generations the CA is to be computed.

Game of life is then run for 9 generations for e.g. a turbine pattern by typing

`ca = CA2d([3], [2, 3], init, 9)`

1st step

``````   ###### ##
###### ##
##
##     ##
##     ##
##     ##
##
## ######
## ######
``````

2nd

``````    ####
#    # ##
#    #   #
##    #
##    #  #
#  #   #  #
#  #    ##
#    ##
#   #    #
## #    #
####
``````

3rd

``````     ##
####
# ## ## #
##  #
##  ##  ###
#### #  ###
#  #   #  #
###  # ####
###  ##  ##
#  ##
# ## ## #
####
##
``````

4th

``````    #  #
#
##
# ##      #
#  #   #
#   # ###
#           #
### #   #
#   #  #
#      ## #
##
#
#  #
``````

5th

``````        ##
#
###  ##
### #   #
#    # ##
# #
## #    #
#   # ###
##  ###
#
##
``````

6th

``````        ##
#
# #  ##
# # ###  #
#  ######
## ##
######  #
#  ### # #
##  # #
#
##
``````

7th

``````     #  # #
## # ###
#      #
##     #

#     ##
#      #
### # ##
# #  #
``````

8th

``````    ## ## #
##  ## ##
#
##
##     ##
##
#
## ##  ##
# ## ##
``````

9th

``````   ###### ##
###### ##
##
##     ##
##     ##
##     ##
##
## ######
## ######
``````

## Running Tests

To run tests, execute the following command from the root folder of the repository:

`julia tests/run_tests.jl`