Sergiu Ivanov
c7912705ca

5 months ago  

example  5 months ago  
scribblings  5 months ago  
LICENSE  1 year ago  
README.org  5 months ago  
functions.rkt  10 months ago  
generic.rkt  1 year ago  
info.rkt  5 months ago  
networks.rkt  5 months ago  
rs.rkt  6 months ago  
utils.rkt  6 months ago 
README.org
dds: A Homemade Toolkit for Discrete Dynamical Systems in Racket
This is a toolkit for playing with various discrete dynamical systems in Racket. A discrete dynamical system is a system which evolves from a discrete state to some other discrete states (many or one). The systems are discrete in the sense that we can identify successive states with no other states in between. Equivalently, the phase state of the system is discrete (and is often called the state graph). These constraints imply the possibility of associating discrete, possibly branching timelines to any evolution of the system.
DISCLAIMER: I develop this toolkit as a support for my research on discrete dynamical systems. The primary objective for this framework is to fit my approach to these systems. Essentially, this framework should fit to the "shape of my mind", which is not necessarily the same as yours.
Currently, the toolkit includes the following files:

generic.rkt: The generic interface for a discrete dynamical system, with functions for constructing state graphs.

utils.rkt: Misc utility functions.

networks.rkt: Implements networkbased models, which generalise Boolean networks, threshold Boolean automata networks, multivalued networks, etc.

rs.rkt: Implements reaction systems, a variant of set rewriting.
The toolkit is designed with Emacs Orgmode interoperability in mind. The file example/example.org explains the features available for interaction with Orgmode.
Roadmap
Here is my current roadmap for this toolkit, in order. The first element is what I am currently working on. The degree of certainty that I work on the subsequent items decreases with their position in the list.
TODO
Convert dds
to Typed Racket
Rewriting dds
with Typed Racket will be a major refactoring,
consisting in the following 3 phases which will happen more or
less in parallel:

define types, add type signatures, add types for functions I import from
graph
; 
transfer the comments from the source files to Scribble documentation;

redefine the generic interface for dynamics, which is currently in
generics
.
I plan to implement the new dynamics interface as a classes, since Typed Racket can now type classes. I didn't really like generics: they are quite cumbersome, and I think I can do more with classes.
People on Racket Users suggested using structures with fields containing functions, but it does not seem to get me to my goal of having typelevel methods/functions.
The order in which I will convert the modules:

utils

functions

dynamics
(currentlygenerics
) 
networks

rs
This is how I will convert a module A
:

Create a copy
Auntyped.rkt
. 
Empty
A.rkt
. 
Transfer the definitions from
Auntyped.rkt
toA.rkt
one by one, adding the necessary types, signatures, and typed imports as I go. 
When done, remove
Auntyped.rkt
.
TODO
Split networks
into general networks and threshold Boolean networks
TODO
Submit updategraph
to stchang
TODO Implement the BN → RS conversion
TODO Implement the minimisation of TBF/SBF
TODO Contribute to Racket

Make sequencefilter allow multivalued sequences, provided the arity of the predicate is consistent with the arity of the sequence.

Add a sequence>hash function that accepts a multivalued sequence of keys and values (exactly like what inhash produces) and copies them into a hash table.