#lang typed/racket ;;; dds/bn ;;; This module provides some quick definitions for running Boolean ;;; networks. A Boolean network is a set of Boolean variables which ;;; are updated according to their corresponding update functions. ;;; The variables to be updated at each step are given by the mode. (require "utils.rkt") (provide Variable State UpdateFunc Network update make-state make-bn update-func-form->update-func bn-form->bn) ;;; ================= ;;; Basic definitions ;;; ================= (define-type Variable Symbol) ;;; A state of a Boolean network is a mapping from the variables of the ;;; network to their Boolean values. (define-type State (HashTable Variable Boolean)) ;;; An update function is a Boolean function computing a Boolean value ;;; from the given state. (define-type UpdateFunc (-> State Boolean)) ;;; A Boolean network is a mapping from its variables to its update ;;; functions. (define-type Network (HashTable Variable UpdateFunc)) ;;; Given a state s updates all the variables from xs. This ;;; corresponds to a parallel mode. (: update (-> Network State (Listof Variable) State)) (define (update bn ; the Boolean network s ; the state to operate on xs) ; the variables to update (let ([new-s : State (hash-copy s)]) (for ([x xs]) (let ([f (hash-ref bn x)]) (hash-set! new-s x (f s)))) new-s)) ;;; A version of make-hash restricted to creating Boolean states. (: make-state (-> (Listof (Pairof Variable Boolean)) State)) (define (make-state mappings) (make-hash mappings)) ;;; A version of make-hash restricted to creating Boolean networks. (: make-bn (-> (Listof (Pairof Variable UpdateFunc)) Network)) (define (make-bn funcs) (make-hash funcs)) ;;; ========================================= ;;; Syntactic description of Boolean networks ;;; ========================================= ;;; An UpdateFuncForm is any form which can appear as a body of a ;;; Boolean function and which can be evaluated with eval. For ;;; example, '(and x y (not z)). (define-type UpdateFuncForm Any) ;;; A Boolean network form is a mapping from its variables to the ;;; forms of their update functions. (define-type NetworkForm (HashTable Variable UpdateFuncForm)) ;;; Build an update function from an update function form. #;(: update-func-form->update-func (-> UpdateFuncForm UpdateFunc)) (define (update-func-form->update-func form) (lambda ([s : State]) (cast (eval-with1 (cast s (HashTable Variable Any)) form) Boolean))) ;;; Build a Network from a Network form. (: bn-form->bn (-> NetworkForm Network)) (define (bn-form->bn bnf) (make-hash (hash-map bnf (lambda ([x : Variable] [form : UpdateFuncForm]) (cons x (update-func-form->update-func form))))))