1665369120

# CellularAutomata.jl: Cellular Automata Simulation toolkit for Julia

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

Author: Natj
Source Code: https://github.com/natj/CellularAutomata.jl

1665369120

## CellularAutomata.jl: Cellular Automata Simulation toolkit for Julia

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

Author: Natj
Source Code: https://github.com/natj/CellularAutomata.jl

1594812357

## Simulating COVID-19 with Cellular Automata

Take a look at the code that goes along with this article. Try running it yourself and messing with parameters.

## COVID-19

Modeling the spread of a novel virus and its resulting disease is an important step in learning proper preventive measures. So far there have been many new simulations that have been created to cover different areas of SARS-CoV-2 or COVID-19. For example, the Washington Post made a great article showing the importance of social distancing. With this article, I try my hand at simulating this disease and through this I hope to spread the importance of safety precautions.

## What are cellular automata?

Cellular Automata are discrete models that consist of a grid of cells where each cell can be a certain state from a given set of states. Every time step each cell is updated to a new state based on its neighbors’ states and simple rules. They have been used to model different areas from artificial life to forest fire propagationConway’s Game of Life is a popular cellular automation that creates complex structures with very simple rules.

#cellular-automata #covid19 #simulation #epidemic #python

1666526160

## Graft.jl

A graph toolkit for Julia.

Graft stores vertex and edge metadata in separate dataframes. Adjacencies are stored in a sparsematrix, which also indexes into the edge dataframe. Vertex labels are supported for all external queries, using a bidirectional map. Vertex labels may be of any Julia type.

Data manipulation and analysis in Graft is accomplished with a pipelined query macro system adopted from Jplyr. User queries are parsed recursively, to build a DAG. The DAG is then executed from the bottom up. Results from the execution of intermediate nodes or table data-retrievals are cached to avoid redundant computations.

## Installation

``````julia> Pkg.update()
``````

## Acknowledgements

This project is supported by `Google Summer of Code` and mentored by Viral Shah and Shashi Gowda.

Author: Pranavtbhat
Source Code: https://github.com/pranavtbhat/Graft.jl

1655818463

## DFTK.jl: Density-functional toolkit

Density-functional toolkit

The density-functional toolkit, DFTK for short, is a collection of Julia routines for experimentation with plane-wave density-functional theory (DFT). The unique feature of this code is its emphasis on simplicity and flexibility with the goal of facilitating algorithmic and numerical developments as well as interdisciplinary collaboration in solid-state research.

Having started in 2019 we already support a sizeable set of features. Within the system size currently accessible to our code (ca. 1000 electrons) our performance is of the same order of magnitude as more established packages such as Abinit or Quantum Espresso.

For getting started with DFTK, see our documentation:

Note that at least Julia 1.6 is required.

## DFTK summer school 2022

We will organise a summer school centred around the DFTK code and modern numerical approaches to density-functional theory from 29 to 31 August 2022 at Sorbonne Université, Paris. For more details see the school's website.

## Support and citation

DFTK is mostly developed as part of academic research. Parts of DFTK have also been discussed in published papers. If you use our code as part of your research, teaching or other activities, we would be grateful if you cite them as appropriate. See the CITATION.bib in the root of this repo for relevant references. The current DFTK reference paper to cite is .

## Funding

This project has received funding from the Institute of computing and data sciences (ISCD, Sorbonne Université), École des Ponts ParisTech, Inria Research Centre Paris, RWTH Aachen University, and from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation program (grant agreement No 810367).

## Contributing

If you stumble across issues in using DFTK or have suggestions for future developments we are more than happy to hear about it. In this case please open an issue or contact us (@mfherbst and @antoine-levitt) directly.

Contributions to the code in any form is very welcome, just submit a pull request on github. If you want to contribute but are unsure where to start, take a look at the list of issues tagged good first issue (relatively easy tasks suitable for newcomers) or help wanted (more sizeable but well-defined and isolated). Don't hesitate to ask for help, through github, email or the JuliaMolSim slack.

Author: JuliaMolSim
Source Code: https://github.com/JuliaMolSim/DFTK.jl

1666818000

## The "Programming the Finite Element Method" toolkit

This Julia package currently contains the programs in chapters 4, 5 and early sections of 6 as described in "Programming the Finite Element Method" by I M Smith, D V Griffiths and L. Margetts (PtFEM).

I use PtFEM when referring to the book and PtFEM.jl when referring to the Julia package. The authors and publisher have given permission to publish the Julia version of the PtFEM toolkit. Please refer to LICENSE for more details.

## Documentation

PtFEM, the book, will always remain the primary documentation for this package. Additional programming documentation will be available through Julia's documenter package, e.g. in-line after installing the package:

``````use PtFEM
?StructuralElement
``````

and full documentation can be found here.

## Timeline

Please note that no hard timeline is set when this work in progress will be finished. TODO contains a list of next steps. VERSIONS holds the tagged version history.

## Related work

Fundamental and great development work related to solving (partial) differential equations is done in several other Julia packages, e.g. ApproxFun.jl, DifferentialEquations.jl, JuliaFEM.jl and JuaFEM.jl to name a few.

Outside of Julia at least 2 other toolkits should be mentioned, i.e. deal.II and FEniCS.

## Rerences

References will be kept here.

## Participation and feedback

As always, feedback is welcome, please send me an email, file an issue on Github or generate a pull request (PR).

Rob J Goedman July 2018