a collection of cellular automata written in Haskell with Diagrams

Available items

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? **Create a request here**:

Readme

Pretty cellular automata in Haskell. The aim is to have most Cellular Automata implemented in this package so it can serve as a reference / library to write Cellular Automata.

stepCell :: Grid -> Cell stepCell grid = cell' where cell' = if numNeighbours > 3 then Off else if numNeighbours < 2 then Off else if cell == Off && numNeighbours == 3 then On else cell cell = extract grid numNeighbours = liveNeighbourCount $ grid

stepCell :: Grid -> Cell stepCell grid = cell' where cell' = if numNeighbours == 2 then On else Off numNeighbours = liveNeighbourCount $ grid

stepCell :: Grid -> Cell stepCell grid = cell' where cell' = if cell == Off && numNeighbours == 2 then On else if cell == On then Dying else Off cell = extract grid numNeighbours = liveNeighbourCount $ grid

stepCell :: Simulation -> Cell stepCell s = cell' where cell = extract s cell' = if hasNextNeighbour (getRingZipperNeighbours s) then Cell { value = (Cyclic1D.value cell + 1) `mod` (total cell), total = total cell} else cell hasNextNeighbour neighbours = any (\c -> Cyclic1D.value c == ((Cyclic1D.value cell) + 1) `mod` (total cell)) neighbours

stepCell :: Grid -> Cell stepCell s = cell' where cell = extract s cell' = if hasNextNeighbour (getUnivNeighbours s) then Cell { val = (val cell + 1) `mod` (total cell), total = total cell} else cell hasNextNeighbour neighbours = any (\c -> val c == ((val cell) + 1) `mod` (total cell)) neighbours

https://qlfiles.net/the-ql-files/next-nearest-neighbors-cellular-automata

This is an exploration of the Haskell design space to create Cellular Automata.

Comonadsto represent the grid space of the cellular automata. The difference between this implementation and many others in the wild is that this one has a

Zipperand

Comonadharder.

This will be refactored into a library that allows one to create cellular automata by simply
specifying the ruleset and the way to draw a *single* cell. The library will extrapolate the data
to allow rendering the entire grid.

Please send a PR to create more Cellular Automata by using an existing cellular automata file (for example,

Seeds(https://github.com/bollu/cellularAutomata/blob/master/src/Seeds.hs)).

If someone knows how to make GIF rendering faster, that would be of great help as well!

As a college student, I write code for passion projects like this on my free time. If you want to support me to see more stuff like this, please

As stated before, this simulation uses the

Comonadtypeclass to model cellular automata. There are multiple ways of looking at this algebra, and one way to think of them is a structure that can automatically convert "global-to-local" transforms into "global-to-global" transforms.

For example, in a cellular automata, the "global-to-local" transformation is updating the state of *one* Cell by reading the cell's neighbours.
The neighbour state is the global state, which is used to update the local state of the cell. This can be thought of as the type

haskell Grid -> Cell

where

Gridis the grid in which the cellular automata is running, and

Cellis the new state of the cell. However, the question that immediately arises is - which cell? the answer is that, the

Gridnot only encodes the state of the cellular automata, but also a

The

Gridis not just a grid, it is a grid with a cell that it is targeted on. However, this seems ridiculous, since we have simply added extra complexity (that of focusing on a particular cell) with zero gains in benefit.

The nice part of a

Comonadis that if we have a structure that knows how to do a "focused update", the

Comonadenables us to extend this to the entire structure. Written in types, it is along the lines of

haskell Grid -> (Grid -> Cell) -> Grid

If we think of grid as a container of cells (or as a functor

w), this gives us the new type

haskell Grid -> (Grid -> Cell) -> Grid -- replace Grid with w Cell w Cell -> (w Cell -> Cell) -> w Cell -- replace Cell with type variable a w a -> (w a -> a) -> w a -- generalize type even further, by allowing the -- output type to differ -- (this is shown to be possible with an implementation later on) w a -> (w a -> b) -> w bNote that this rewrite exploited the fact that a

Gridis simply a functor (collection) of

Cells, and then used this to rewrite the type signature.

The type signature

haskell w a -> (w a -> b) -> w bcan be sharply contrasted with the monadic

>>= (bind)as ```haskell

= :: m a -> (a -> m b) -> m b ```

Indeed, these structures are dual, which is why there are called as

Comonad, which is also why I picked

was the symbol for

Comonad(which is an upside-down

mfor

Monad). It is usually called as "cobind", and is written as

haskell =>> :: w a -> (w a -> b) -> w bwith the interpretation that it takes a global structure

w awhich is focused on some

ain the

w a, and then takes a transform that updates the focused

ain the

w ato a

b. Given these two pieces of information, the Comonad automatically updates every single

a, to produce an updated

w b.

Storecomonad

Now, we will show a particular comonad, the

Store, which forms the underlying comonad for this implementation

data Store s a = Store { sextract :: s -> a, sval :: s }instance Functor (Store s) where fmap f (Store xtract v) = Store (f . xtract) v

instance Comonad (Store s) where extract :: Store s a -> a extract (Store xtract v) = xtract v

(>>=) :: Store s a -> (Store s a -> b) -> Store s b [email protected](Store xtract v) >>= f = let b = f store xtract' s = f (Store xtract s) in Store b xtract'

-- this worksderiveMonoElement :: Type -> Type -> Q[Dec] deriveMonoElement tnewtype telem = [d| type instance Element (tnewtype) = $(return telem) |]

-- this doesn't deriveMonoElement :: Type -> Type -> Q[Dec] deriveMonoElement tnewtype telem = [d| type instance Element (tnewtype) = telem |]

-- Why can I use

`tnewtype`

as a "raw" value while I can't with`telem`

? -- Why does`$(return telem)`

work while raw`telem`

doesn't?

The MIT License (MIT) Copyright (c) 2016 Siddharth BhatPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ``