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.jlDownload Details:
Author: Natj
Source Code: https://github.com/natj/CellularAutomata.jl
License: MIT license
What is GEEK
Buddha Community
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.jlDownload Details:
Author: Natj
Source Code: https://github.com/natj/CellularAutomata.jl
License: MIT license
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 propagation. Conway’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: Graph Toolkit for Julia
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()
julia> Pkg.add("Graft")
Examples
Acknowledgements
This project is supported by Google Summer of Code and mentored by Viral Shah and Shashi Gowda.
Download Details:
Author: Pranavtbhat
Source Code: https://github.com/pranavtbhat/Graft.jl
License: View license
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.
| Documentation | Build Status | License |
|---|---|---|
 |
Author: JuliaMolSim
Source Code: https://github.com/JuliaMolSim/DFTK.jl
License: MIT license
1666818000
PtFEM.jl: The "Programming The Finite Element Method" toolkit
PtFEM
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
Download Details:
Author: PtFEM
Source Code: https://github.com/PtFEM/PtFEM.jl
License: View license