133 lines
3.5 KiB
Racket
133 lines
3.5 KiB
Racket
#lang scribble/manual
|
|
@(require scribble/example racket/sandbox
|
|
(for-label typed/racket/base
|
|
(submod "../tbn.rkt" typed)
|
|
"../networks.rkt"
|
|
"../utils.rkt"
|
|
"../functions.rkt"
|
|
"../dynamics.rkt"))
|
|
|
|
@(define tbn-evaluator
|
|
(parameterize ([sandbox-output 'string]
|
|
[sandbox-error-output 'string]
|
|
[sandbox-memory-limit 500])
|
|
(make-evaluator 'typed/racket #:requires '((submod "tbn.rkt" typed)))))
|
|
|
|
@(define-syntax-rule (ex . args)
|
|
(examples #:eval tbn-evaluator . args))
|
|
|
|
@(define-syntax-rule (deftypeform . args)
|
|
(defform #:kind "type" . args))
|
|
|
|
@(define-syntax-rule (deftype . args)
|
|
(defidform #:kind "type" . args))
|
|
|
|
@title[#:tag "tbn"]{dds/tbn: Threshold and Sign Boolean Networks (TBN and SBN)}
|
|
|
|
@defmodule[(submod dds/tbn typed)]
|
|
|
|
@section{TBFs and states}
|
|
|
|
This module defines threshold Boolean networks (TBN), as well as sign
|
|
Boolean networks (SBN). The update functions in such networks are
|
|
respectively @seclink["tbf" #:doc '(lib
|
|
"dds/scribblings/dds.scrbl")]{threshold Boolean functions} and sign
|
|
Boolean functions.
|
|
|
|
@defproc[(apply-tbf-to-state [a-tbf TBF] [st (State (U Zero One))])
|
|
(U Zero One)]{
|
|
|
|
Applies a TBF to a state.
|
|
|
|
The values of the variables of the state are ordered by
|
|
@racket[hash-map] and fed to the TBF in order. The number of the
|
|
inputs of the TBF must match the number of variables in the state.
|
|
|
|
@ex[
|
|
(require "functions.rkt")
|
|
(apply-tbf-to-state (tbf #(1 1) 1) (hash 'x1 0 'x2 1))
|
|
]}
|
|
|
|
@defstruct*[tbf/state ([weights (VariableMapping Real)]
|
|
[threshold Real])]{
|
|
|
|
A state TBF is a @racket[TBF] with named inputs. A state TBF can be
|
|
applied to states in an unambiguous ways.
|
|
|
|
}
|
|
|
|
@deftype[TBF/State]{
|
|
|
|
The type of the instances of @racket[tbf/state].
|
|
|
|
}
|
|
|
|
@deftogether[(@defproc[(tbf/state-w [tbfs TBF/State]) (VariableMapping Real)]
|
|
@defproc[(tbf/state-θ [tbfs TBF/State]) Real])]{
|
|
|
|
Shorter synonyms for field accessors of @racket[tbf/state].
|
|
|
|
@ex[
|
|
(let ([tbfs (tbf/state (hash 'a 1 'b 1) 1)])
|
|
(values (tbf/state-w tbfs)
|
|
(tbf/state-θ tbfs)))
|
|
]}
|
|
|
|
@defproc[(make-tbf/state [pairs (Listof (Pairof Variable Real))]
|
|
[threshold Real])
|
|
TBF/State]{
|
|
|
|
Makes a @racket[TBF/State] from a list of pairs of names of variables
|
|
and weights, as well as a threshold.
|
|
|
|
@ex[
|
|
(make-tbf/state '((x1 . 1) (x2 . 1)) 1)
|
|
]}
|
|
|
|
@defproc[(sbf/state? [tbfs TBF/State]) Boolean]{
|
|
|
|
A state sign Boolean function (SBF) is a @racket[TBF/State] whose
|
|
threshold is 0.
|
|
|
|
@ex[
|
|
(sbf/state? (tbf/state (hash 'a -1 'b 1) 0))
|
|
(sbf/state? (tbf/state (hash 'a -1 'b 1) 1))
|
|
]}
|
|
|
|
@defproc[(apply-tbf/state [tbfs TBF/State]
|
|
[st (State (U Zero One))])
|
|
(U Zero One)]{
|
|
|
|
Applies a @racket[TBF/State] to its inputs given by the state
|
|
@racket[st].
|
|
|
|
Applying a TBF consists in multiplying the weights by the
|
|
corresponding inputs and comparing the sum of the products to
|
|
the threshold.
|
|
|
|
This function is similar to @racket[apply-tbf], but because it applies
|
|
a @racket[TBF/State] to a @racket[(State (U Zero One))], it avoids
|
|
potential mismatches between weights and the corresponding
|
|
input values.
|
|
|
|
@ex[
|
|
(apply-tbf/state (tbf/state (hash 'a 2 'b -2) 1)
|
|
(hash 'a 1 'b 0 'c 1))
|
|
]}
|
|
|
|
@section{Reading TBFs and SBFs}
|
|
|
|
@defproc[(lists+vars->tbfs/state [vars (Listof Variable)]
|
|
[lsts (Listof (Listof Real))])
|
|
(Listof TBF/State)]{
|
|
|
|
Reads a list of @racket[TBF/State] from a list of list of
|
|
@racket[Real]s.
|
|
|
|
The last element of each list is taken to be the threshold of the
|
|
TBFs, and the rest of the elements are taken to be the weights.
|
|
|
|
@ex[
|
|
(lists+vars->tbfs/state '(x y) '((1 2 3) (1 1 2)))
|
|
]}
|