64 lines
2.0 KiB
Racket
64 lines
2.0 KiB
Racket
#lang typed/racket
|
|
|
|
;;; dds/rs
|
|
|
|
;;; Definitions for working with reaction systems.
|
|
|
|
(provide
|
|
;; Structures
|
|
reaction
|
|
;; Type names
|
|
Species ReactionSystem
|
|
;; Functions
|
|
enabled? list-enabled union-products apply-rs)
|
|
|
|
;;; =================
|
|
;;; Basic definitions
|
|
;;; =================
|
|
|
|
;;; A species is a symbol.
|
|
(define-type Species Symbol)
|
|
|
|
;;; A reaction is a triple of sets, giving the reactants, the
|
|
;;; inhibitors, and the products, respectively.
|
|
(struct reaction ([reactants : (Setof Symbol)]
|
|
[inhibitors : (Setof Symbol)]
|
|
[products : (Setof Symbol)]))
|
|
|
|
;;; A reaction is enabled on a set if all of its reactants are in the
|
|
;;; set and none of its inhibitors are.
|
|
(: enabled? (-> reaction (Setof Symbol) Boolean))
|
|
(define/match (enabled? r s)
|
|
[((reaction r i p) s)
|
|
(and (subset? r s) (set-empty? (set-intersect i s)))])
|
|
|
|
;;; A reaction system is a dictionary mapping reaction names to
|
|
;;; reactions.
|
|
(define-type ReactionSystem (HashTable Symbol reaction))
|
|
|
|
;;; Returns the list of reaction names enabled on a given set.
|
|
(: list-enabled (-> ReactionSystem (Setof Species) (Listof Symbol)))
|
|
(define (list-enabled rs s)
|
|
(for/list ([(name reaction) (in-hash rs)]
|
|
#:when (enabled? reaction s))
|
|
name))
|
|
|
|
;;; Returns the union of the product sets of the given reactions in a
|
|
;;; reaction system.
|
|
;;;
|
|
;;; This function can be seen as producing the result of the
|
|
;;; application of the given reactions to a set. Clearly, it does not
|
|
;;; check whether the reactions are actually enabled.
|
|
(: union-products (-> ReactionSystem (Listof Symbol) (Setof Species)))
|
|
(define (union-products rs as)
|
|
(apply set-union
|
|
((inst set Species)) ; set-union requires at least one argument
|
|
(for/list : (Listof (Setof Species))
|
|
([a as]) (reaction-products (hash-ref rs a)))))
|
|
|
|
;;; Applies a reaction system to a set.
|
|
(: apply-rs (-> ReactionSystem (Setof Species) (Setof Species)))
|
|
(define (apply-rs rs s)
|
|
(let ([as (list-enabled rs s)])
|
|
(union-products rs as)))
|