source: project/ode/trunk/ode-eggdoc.scm @ 7358

Last change on this file since 7358 was 7358, checked in by Ivan Raikov, 12 years ago

Updated author address.

File size: 41.9 KB
Line 
1;;
2;;
3;; ode documentation for the Chicken Scheme module system.
4;;
5;; This program is free software: you can redistribute it and/or
6;; modify it under the terms of the GNU General Public License as
7;; published by the Free Software Foundation, either version 3 of the
8;; License, or (at your option) any later version.
9;;
10;; This program is distributed in the hope that it will be useful, but
11;; WITHOUT ANY WARRANTY; without even the implied warranty of
12;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13;; General Public License for more details.
14;;
15;; A full copy of the GPL license can be found at
16;; <http://www.gnu.org/licenses/>.
17;;
18;;
19
20(use eggdoc)
21
22(define doc
23  `((eggdoc:begin
24     (name "ode")
25     (description "Numerical solver framework for systems of first-order differential equations (ODE).")
26     (author (url "http://chicken.wiki.br/ivan raikov" "Ivan Raikov"))
27
28     (history 
29      (version "2.7" "Meta-file bug fix")
30      (version "2.6" "Added support for user-specified error tolerances")
31      (version "2.5" "Added the ode-ctranslator extension; "
32               "some reorganization to support foreign-lambdas as rhs procedures")
33      (version "2.4" "Added the ode-pr and ode-hhsp extensions")
34      (version "2.3" "Restructuring of the interp1d extension into waveform extension and new interp1d")
35      (version "2.2" "Bug fixes in the ode macros and in the meta file")
36      (version "2.1" "Added support for vector state functions")
37      (version "2.0" "Changes to the ode runtime interface")
38      (version "1.4" "Bug fixes in the meta file")
39      (version "1.3" "Added sysname method and ode-transform macro")
40      (version "1.2" "Yet more solver bug fixes and adjustments")
41      (version "1.1" "Some bug fixes and fine tuning of the numerical solvers")
42      (version "1.0" "Initial release"))
43
44     (requires (url "args.html"          "args")
45               (url "datatype.html"      "datatype")
46               (url "vector-lib.html"    "vector-lib")
47               (url "environments.html"  "environments")
48               (url "digraph.html"       "digraph")
49               (url "graph-bfs.html"     "graph-bfs")
50               (url "graph-cycles.html"  "graph-cycles")
51               (url "mathh.html"         "mathh")
52               (url "srfi-40.html"       "srfi-40")
53               (url "interp1d.html"      "interp1d")
54               (url "stack.html"         "stack")
55               )
56               
57     (usage "(require-extension ode)")
58
59     (download "ode.egg")
60
61     (documentation
62
63      (p "The " (tt "ode") " library provides a framework that can
64represent several different families of first order differential
65equations.  It includes three distinct algorithms for the numerical
66solution of differential equations: Euler, Runge-Kutta-Fehlberg, and
674th order Adams-Moulton. ")
68
69      (subsection "Definitions"
70
71         (p "A differential equation is an equation that involves an
72unknown function and its derivatives.  A differential equation is
73ordinary if the unknown function depends on only one independent
74variable, often denoted " (tt "t")".  The order of the differential
75equation is the order of the highest-order derivative in the equation.")
76
77         (p "A system of equations is a set of equations that contain
78multiple variables.  If the equations are dependent on one another
79they are said to be coupled.  A solution is any function satisfying
80the equations.  An initial value problem (IVP) is a system of ordinary
81differential equations together with specified initial conditions on
82the unknown functions and their derivatives, all of which are given at
83the same value of the independent variable. ")
84
85         (p "In practical problems, the solution of a differential
86equation is usually not known in terms of an explicit formula, and the
87solution must be numerically approximated. ")
88
89         (p "A numerical method for a system of ordinary differential
90equations produces approximate solutions at particular points using
91only the operations of arithmetic and functional evaluations of the
92given equations.  " (tt "ode") " solves first order initial value
93problems of the form: "
94
95(pre "
96      x' = f(t,x,y,...,z)
97      y' = g(t,x,y,...,z)
98         .
99         .
100         .
101      z' = h(t,x,y,...,z)")
102
103"given the initial values for each dependent variable at  the
104initial value of the independent variable, "
105
106(pre  "
107       x(a) = b
108       y(a) = c
109           .
110           .
111           .
112       z(a) = d
113          t = a")
114
115"where a,b,c,...,d are constants. ")
116
117         (p "In the equations above, " (tt "f, g, ..., and h")
118" can be expressed with the operators " (tt "+,-,*,/") 
119" and the mathematical functions described in the next section. " 
120"In order to solve a system of equations with " (tt "ode") 
121", it must be possible to solve explicitly for each
122derivative.  " (tt "ode") " can't solve an equation in which the first
123derivative is implicitly defined; for instance, the system " 
124(pre "y' + y' = 1")
125         " cannot be solved with " (tt "ode") ". ")
126
127         (p "All numerical integration algorithms calculate an
128approximate solution at successive discrete values of the independent
129variable. The interval between any two successive points is called the
130time step (usually denoted " (tt "dt") ") and it may be constant or
131variable.  In general, as " (tt "dt") " becomes smaller, the solution
132becomes more accurate. ")
133
134   ) ;; end subsection Definitions
135
136
137      (subsection "ODE Interface"
138
139      (p "The " (tt "ode") " interface is structured as an \"object\" --
140a dispatcher procedure that takes a method name as a symbol, and
141returns the procedure that implements the respective operation.
142The " (tt "ode") " object is created by procedure " (tt "make-ode") ": ")
143                   
144       (procedure "make-ode -> ODE"
145         
146          (p "The returned dispatcher procedure can take one of the following arguments: "
147             (symbol-table 
148
149              (describe "'add-guard!" 
150                        ((p "A " (i "guard") " is a boolean expression that always must hold true "
151                           "at the end of an integration cycle. It can be used to test the "
152                           "invariants of a system of equations being developed. ")
153                        (p (tt "add-guard!") " returns a procedure of the form " 
154                           (tt "LAMBDA ODE-ENV -> (LAMBDA EXPR -> UNDEFINED)")
155                           " that when invoked with a particular equation environment, "
156                           "returns a procedure that takes a boolean expression and adds it to the list "
157                           "of guard expressions for that equation environment. "
158                           "This procedure modifies the given equation environment. ")))
159
160              (describe "'defun!"       
161                        ((p "Returns a procedure of the form " 
162                            (tt "LAMBDA ODE-ENV -> (LAMBDA NAME FORMALS BODY -> UNDEFINED)")
163                            " that when invoked with a particular equation environment, "
164                            "defines a new function within that environment. It is an error to define "
165                            "the same function more than once. ")
166                         (p "Argument " (tt "NAME") " is the name of the function and it must be a symbol. "
167                            "Argument " (tt "FORMALS") " is the list of formal arguments to the function, "
168                            " and it must be a list of symbols. Argument " (tt "BODY") " is the body of "
169                            "the function, and it must be an arithmetic expression that only references "
170                            "the formal arguments. ")
171                         (p "This procedure modifies the given equation environment. ")))
172
173              (describe "'depgraph"       
174                        (p "Returns a procedure of the form " 
175                           (tt "LAMBDA ODE-ENV -> DIGRAPH")
176                           "  that when invoked with a particular equation environment, "
177                           "returns the dependency graph of the different quantities in the system. "
178                           "Please see the " (url "digraph.html" "digraph") " egg for details about the "
179                           "graph API used. "))
180
181              (describe "'env-extend!"
182                        ((p "Returns a procedure of the form " 
183                            (tt "LAMBDA ODE-ENV -> (LAMBDA NAME TYPE INITIAL [RHS] -> UNDEFINED)")
184                            " that when invoked with a particular equation environment, "
185                            "defines a new quantity within that environment. It is an error to define the "
186                            "same quantity more than once. ")
187                         (p "Argument " (tt "NAME") " is the name of the quantity and it must be a symbol. "
188                            "Argument " (tt "TYPE") " is a symbol that has one of the following values: " 
189                            (symbol-table
190                             (describe (tt "'const") "constant during integration")
191                             (describe (tt "'state") "state variable")
192                             (describe (tt "'asgn")   ("a quantity that is assigned a "
193                                                      "directly evaluated arithmetic expression during "
194                                                      "integration "))
195                             (describe (tt "'prim")  "primitive (a Scheme value)")
196                             (describe (i "other")   "quantity type defined by an extension module")))
197                         (p "Argument " (tt "INITIAL") " must be a numeric value in the case of constants and state "
198                            "variables, the symbol " (tt "'(none)") " in the case of assigned quantities, "
199                            "or a Scheme value in the case of primitives. ")
200                         (p "Argument " (tt "RHS") " is optional and allowed only in the case of states or "
201                            "assigned quantities and is an arithmetic expression that represents the right-hand "
202                            "side of the equation for that quantity. ")
203                         (p "This procedure modifies the given equation environment. ")))
204
205
206              (describe "eqdef!"
207                        ((p "Returns a procedure of the form " 
208                            (tt "LAMBDA ODE-ENV -> (LAMBDA NAME RHS [DF] -> UNDEFINED)")
209                            " that when invoked with a particular equation environment, "
210                            "defines the right-hand side of the equation for the specified quantity. "
211                            "It is an error to specify the right-hand side of the same quantity more "
212                            "than once, or to refer to a quantity that has not been defined with "
213                            (tt "env-extend!") ". ")
214                         (p "Argument " (tt "RHS") " is required only in the case of states or assigned quantities "
215                            "and is an arithmetic expression that represents the right-hand side of the equation "
216                            "for that quantity. ")
217                         (p "Optional argument " (tt "DF") " can specify if this is a difference equation, "
218                            "when the quantity being referred is a system state. " (tt "DF") " can take the values "
219                            " of " (tt "'d") " (the default), to indicate a differential equation, or " (tt "'q")
220                            ", to indicate a difference equation. ")
221                         (p "This procedure modifies the given equation environment. ")))
222
223              (describe "eval-const"
224                        ((p "Returns a procedure of the form " (tt "LAMBDA ODE-ENV EXPR -> NUMBER")
225                            " that when invoked with an equation environment and an expression "
226                            "evaluates the expression and returns its numeric value. ")
227                         (p "The expression must refer only to constants and primitive procedures "
228                            "that have already been defined in the equation environment. ")))
229             
230              (describe "make-const-env"
231                        (p "Returns a procedure of the form " (tt "LAMBDA ODE-ENV -> ENV")
232                           " that when invoked with an equation environment "
233                           "returns an environment that contains only the constants and primitive functions "
234                           "from the given equation environment. "))
235             
236              (describe "exam"
237                        (p "Returns a procedure of the form "
238                           (tt "LAMBDA ODE-ENV -> (LAMBDA NAME -> UNDEFINED)")
239                           " that when invoked with a particular equation environment, "
240                           "prints information about the specified quantity. It is an error to specify an "
241                           "undefined quantity. "))
242
243              (describe "'set-indep!" 
244                        ((p "Returns a procedure of the form " 
245                            (tt "LAMBDA ODE-ENV -> (LAMBDA NAME -> UNDEFINED)")
246                            " that when invoked with a particular equation environment, "
247                            "sets the name of the independent variable (default: " (tt "t") "). ")
248                         (p "This procedure modifies the given equation environment. ")))
249
250
251              (describe "set-print!" 
252                        ((p "Returns a procedure of the form "
253                            (tt "LAMBDA ODE-ENV -> PRTLIST [EVERY [FROM]] -> UNDEFINED") 
254                            " which specifies a list of quantities to be printed during "
255                            "the numerical integration process. ")
256                         (p "Argument " (tt "PRTLIST") " is a list in which every element is of the form "
257                            (tt "(TAG SYM)") ". " (tt "SYM") " is the name of a quantity in the system, and "
258                            (tag "TAG") " is a symbol with one of the following values: " 
259                            (tt "VALUE, PRIME, ABSERR, RELERR"))
260                         (p "The optional argument " (tt "EVERY") " specifies that the quantities must be "
261                            "printed only when the number of iterations is a multiple of " (tt "EVERY") ". ")
262                         (p "The optional argument " (tt "FROM") " specifies that the quantities must be "
263                            "printed only when the number of iterations exceeds " (tt "FROM") ". ")
264                         (p "This procedure modifies the given equation environment. ")))
265
266              (describe "'set-timestep!" 
267                        ((p "Returns a procedure of the form " 
268                            (tt "LAMBDA ODE-ENV -> (LAMBDA NAME -> UNDEFINED)")
269                            " that when invoked with a particular equation environment, "
270                           "sets the name of the timestep variable (default: " (tt "dt") "). ")
271                         (p "This procedure modifies the given equation environment. ")))
272
273              (describe "step!"
274                        ((p "Returns a procedure of the form "
275                           (tt "LAMBDA ODE-ENV -> (LAMBDA SOLVER START STOP [INITIAL-H] -> UNDEFINED)")
276                           " that when invoked, performs the numerical step from " (tt "START") " to "
277                           (tt "STOP") ". ") 
278                         (p "Argument " (tt "SOLVER") " is the solver procedure to use; "
279                            "please see the next section for information about the solver interface, and "
280                            "files " (tt "euler.scm") ", " (tt "rkf45.scm") ", " (tt "abm4.scm") " in the "
281                            "egg distribution for examples of different solver implementations. ")
282                         (p "Optional argument " (tt "INITIAL-H") " can be used to specify initial time step. ")
283                         (p "This procedure modifies the given equation environment. ")))
284
285              (describe "'system"       
286                        (p "Returns a procedure of the from " (tt "LAMBDA NAME -> ODE-ENV") 
287                           " that when invoked, returns an environment that represents a "
288                           "system of equations. "))
289
290              (describe "'sysname"       
291                        (p "Returns a procedure of the from " (tt "LAMBDA ODE-ENV -> NAME") 
292                           " that when invoked with an ODE environment argument, returns the name for that "
293                           "system of equations. "))
294
295              )) )
296
297       (procedure "ode:env-copy:: ODE-ENV -> ODE-ENV"
298                  "This procedure makes a copy of the given equation environment. ")
299
300
301
302
303   ) ;; end subsection ODE Interface
304
305      (subsection "Arithmetic Expressions"
306
307        (p "Each right-hand side expression is an s-expression in which the quantities of the system "
308           "and the built-in arithmetic functions and constants are recognized. ")
309        (p "The following built-in functions and constants are currently defined: "
310
311           (subsubsection "Built-in Arithmetic Functions"
312              (tt "+ - * / pow neg abs atan asin acos sin cos ceiling floor exp ln sqrt tan "
313                  "cosh sinh tanh hypot gamma lgamma log10 log2 log1p ldexp "
314                  "cube round ceiling floor max min"))
315           (subsubsection "Built-in Constants"
316              (tt "E 1/E E^2 E^PI/4 LOG2E LOG10E LN2 LN3 LNPI LN10 1/LN2 1/LN10 PI PI/2 "
317                  "PI/4 1/PI 2/PI 2/SQRTPI SQRTPI PI^2 DEGREE SQRT2 1/SQRT2 SQRT3 SQRT5 "
318                  "SQRT10 CUBERT2 CUBERT3 4THRT2 GAMMA1/2 GAMMA1/3 GAMMA2/3 PHI LNPHI "
319                  "1/LNPHI EULER E^EULER SIN1 COS1 ZETA3")))
320
321         (p "In addition, a right hand side expression can include an if-statement "
322            "of the form " (tt "IF COND IFTRUE IFFALSE") ". " "The given condition "
323            "must be a boolean expression; if it is true, then the " (tt "IFTRUE") 
324            " expression is evaluated and its value returned; otherwise the " (tt "IFFALSE") 
325            " expression is evaluated and its value returned. ")
326 
327   ) ;; end subsection Arithmetic Expressions
328
329      (subsection "Guard Expressions"
330
331        (p "Guard expressions are a sequence of boolean expressions "
332           "that must hold true at the end of each integration cycle. "
333           "Guard expressions can include all of the built-in "
334           "arithmetic functions, system quantities, as well as the following boolean functions: "
335           (tt "> < <= >= = and or"))
336
337       ) ;; end subsection Guard Expressions
338
339      (subsection "Solver Interface"
340
341           (p "The " (tt "step!") " procedure invokes a particular solver procedure "
342              "with an argument " (tt "ODE-RUNTIME") " which is a dispatcher procedure "
343              "that recognizes the following messages: ")
344            (symbol-table 
345              (describe "'order"             "Returns the number of states in the system")
346              (describe "'svec-value-idx"    ("The index at which the quantity value is stored in "
347                                              "the numeric vector associated with each quantity "
348                                              "during an integration run"))
349              (describe "'svec-deriv-idx"    ("The index at which the derivative value is stored in "
350                                              "the numeric vector associated with each quantity "
351                                              "during an integration run"))
352              (describe "'svec-abserr-idx)"  ("The index at which the absolute error value is stored in "
353                                              "the numeric vector associated with each quantity "
354                                              "during an integration run"))
355              (describe "'svec-relerr-idx"   ("The index at which the relative error value is stored in "
356                                              "the numeric vector associated with each quantity "
357                                              "during an integration run"))
358
359              (describe "'is-state?"         ("Given a symbol, returns true if the symbol is the name "
360                                              "of a state in the given equation system"))
361              (describe "'is-asgn?"          ("Given a symbol, returns true if the symbol is the name "
362                                              "of a state equation quantity in the given equation system"))
363
364              (describe "'eval-poset-foreach"
365                        ((p "Given a procedure of the form " (tt "LAMBDA ORDER LST") " evaluates the procedure once "
366                            "for each quantity in the equation system, grouped according to their evaluation order. ")
367                         (p "Argument " (tt "ORDER") " is the evaluation order index. ")
368                         (p "Argument " (tt "LST") " is the list of all quantities that have evaluation order " 
369                            (tt "ORDER") ". " "Each element of the list is of the form  " (tt "(SYM . RHS") 
370                            " which are respectively the name and the equation right-hand side for that quantity. ")))
371
372              (describe "'eval-poset-fold"
373                        ("The same as " (tt "eval-poset-foreach") " but performs a fold-like operation. "
374                         "The given procedure must take an additional argument for the fold accumulator value. "))
375
376              (describe "'eval-env-ref"  "Returns the value of a quantity in the current evaluation environment. ")
377              (describe "'eval-env-set!" "Sets the value of a quantity in the current evaluation environment. ")
378
379              (describe "'solve-env-ref"  "Returns the value of a quantity in the current solve environment. ")
380              (describe "'solve-env-set!" "Sets the value of a quantity in the current solve environment. ")
381
382              (describe "'solve-env-state-fold" "Performs a fold-like operation on the states in the solve environment")
383              (describe "'solve-env-state-foreach" "Iterates over the states in the solve environment")
384              (describe "'solve-env-asgn-fold"  ("Performs a fold-like operation on the assigned quantities "
385                                                 "in the solve environment "))
386
387              (describe "'eval-expr"  ("Evaluates the given expression in the evaluation environment "
388                                       "for the current system."))
389
390              (describe "'relmax" "Returns the upper bound relative error for the current system. ")
391              (describe "'relmin" "Returns the lower bound relative error for the current system. ")
392              (describe "'absmax" "Returns the upper bound absolute error for the current system. ")
393              (describe "'absmin" "Returns the lower bound absolute error for the current system. ")
394
395              (describe "'maxerror" "Computes the current highest relative and absolute errors in the system.")
396              (describe "'hierror?" ("Given the return value of the " (tt "maxerror") " procedure, "
397                                     "returns true if the maximum relative or absolute error is exceeded. "))
398              (describe "'lowerror?" ("Given the return value of the " (tt "maxerror") " procedure, "
399                                     "returns true if the error is less than the minimum relative and absolute errors. "))
400
401              (describe "'print" ("Prints the values of the quantities specified by the " (tt "set-print!") 
402                                  "procedure. ")))
403
404   ) ;; end subsection Solver Interface
405
406   (subsection "Macros" 
407
408     (macro "(with-ode-system name declarations . body)"
409        (p "A helper macro for creating ODE systems and simulating "
410           "them with the provided numerical solvers. " (tt "NAME") 
411           " is the name of the variable that will be bound to the ODE system "
412           "object when the statements in " (tt "BODY") " are executed. ")
413        (p "The declaration syntax is the following: "
414            (symbol-table
415             (describe "('prim id value)" "define Scheme values")
416             (describe "('state id '= expr)" "define state quantity")
417             (describe "('indep id)" "define independent variable (default: t)")
418             (describe "(id '= expr)" "define algebraic assignment")
419             (describe "('defun id (arg1 arg2 ...) expr)" "define state function")
420             (describe "('prim id scheme-expr)" "define primitive function or constant (Scheme value)")
421             (describe "('d (id) '= expr)" "define differential equation")
422             (describe "('q (id) '= expr)" "define difference equation")
423             (describe "('guard expr)" "define guard expression")
424             (describe "('guards (expr1 ...))" "define several guard expressions at once")
425             (describe "('print prtlist)" "define quantities to be printed during simulation run"))))
426
427     (macro "(ode-transform sys declarations)"
428
429         (p "This macro applies the given declarations to the given ODE system, and "
430            "returns the modified equation environment. It recognizes the same syntax as " 
431            (tt "with-ode-system") ". "))
432           
433   ) ;; End subsection Macros
434
435   (subsection "Extensions" 
436
437      (subsection "ode-waveform"
438        (p "An extension for waveform generation in ODE systems. ")
439        (p "The recognized syntax is : "
440           (pre "(waveform (NAME (TYPE PROPERTIES ...)))")
441           " where " (tt "TYPE") " and " (tt "PROPERTIES")  " are of the following form: "
442            (symbol-table
443             (describe (tt "interp1d") (tt "((step CONST) (src LIST-OR-STREAM) [(method INTERP-METHOD)]) ") )
444             (describe (tt "sine")     (tt "((amplitude CONST) (rate CONST) "
445                                           "[(phase-shift CONST) (vertical-offset CONST)]) "))
446             (describe (tt "square")   (tt "((amplitude CONST) (period CONST) "
447                                           "[(duty-cycle CONST) (vertical-offset CONST)]) "))
448             (describe (tt "sawtooth") (tt "((amplitude CONST) (period CONST) "
449                                           "[(vertical-offset CONST)]) "))
450             (describe (tt "compose")  (tt "(def1 ...)"))
451             (describe (tt "sum")  (tt "(def1 ...)"))
452             (describe (tt "multiply")  (tt "(def1 ...)"))))
453            )
454
455      (subsection "ode-rate"
456        (p "An extension for rate equations in ODE systems. ")
457        (p "The recognized syntax is: "
458           (pre "(rate ((=> SRC DEST RATE-EXPR) | (<= DEST SRC RATE-EXPR) ...)"))
459       )
460
461      (subsection "ode-hhs"
462        (p "An extension for specifying Hodgkin-Huxley-type dynamics in ODE systems. ") 
463       )
464
465      (subsection "ode-lambda"
466        (p "An extension for creating Scheme procedures in place right-hand side expressions in ODE systems. ")
467       )
468    ) ;; End subsection Extensions   
469
470  ) ;; end documentation
471
472     (examples
473
474(subsection "Simple Examples"
475 (pre #<<EOF
476
477;;;;;;;;;;;;;;;;;;;;;;;;;;;
478;;
479;; Compute Euler's number
480;;
481;;;;;;;;;;;;;;;;;;;;;;;;;;;
482
483(require-extension ode-macros)
484(require-extension ode-abm4)
485
486(with-ode-system euler
487                 ((state y = 1)
488                  (d (y) = y)
489                  (print ((value t) (value y))))
490
491 (((ode 'step!) euler) ode:abm4 0.0 1.0))
492
493;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
494;;
495;; Example 203a in _Numerical Methods for Ordinary Differential
496;; Equations_, by J.C. Butcher.
497;;   
498;; The exact solution of this system is:
499;;
500;;  y1(x) = cos(x)
501;;  y2(x) = sin(x)
502;;
503;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
504
505(require-extension ode-macros)
506(require-extension ode-rkf45)
507
508(with-ode-system b203a
509                 ((indep x)
510                  (state y1 = 1.0)
511                  (state y2 = 0.0)
512                  (d (y1) = (+ (+ (* -16.0 y1) (* 12.0 y2)) (+ (* 16.0 (cos x)) (* -13.0 (sin x)))))
513                  (d (y2) = (+ (+ (* 12.0  y1) (* -9.0  y2)) (+ (* -11.0 (cos x)) (* 9.0  (sin x)))))
514                  (print ((value x) (value y1) (value y2))))
515
516 (((ode 'step!) b203a) ode:rkf45 0.0 1.0))
517
518EOF
519))
520
521(subsection "Hodgkin-Huxley Model"
522 (pre #<<EOF
523
524;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
525;;
526;; This model is used to calculate a neuron's membrane potential
527;; assuming some initial state. The calculation is based on sodium ion
528;; flow, potassium ion flow and leakage ion flow. (Hodgkin, A. L. and
529;; Huxley, A. F. (1952) "A Quantitative Description of Membrane
530;; Current and its Application to Conduction and Excitation in Nerve"
531;; Journal of Physiology 117: 500-544)
532;;
533;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
534
535(require-extension ode-macros)
536(require-extension ode-rkf45)
537(require-extension ode-waveform)
538
539
540(with-ode-system hodgkin-huxley
541                 (;; model states
542                  (state v = -65)
543                  (state m = 0.052)
544                  (state h = 0.596)
545                  (state n = 0.317)
546
547                  ;; input stimulus
548                  (waveform (I_stim (sine (amplitude 10))))
549
550                  ;; model parameters
551                  (const C_m      = 1)
552                  (const E_Na     = 50)
553                  (const E_K      = -77)
554                  (const E_L      = -54.4)
555                  (const gbar_Na  = 120)
556                  (const gbar_K   = 36)
557                  (const g_L      = 0.3)
558
559                  ;; rate functions
560                  (defun amf (v)   (* 0.1    (/ (+ v 40)  (- 1.0 (exp (/ (neg (+ v 40)) 10))))))
561                  (defun bmf (v)   (* 4.0    (exp (/ (neg (+ v 65)) 18))))
562                  (defun ahf (v)   (* 0.07   (exp (/ (neg (+ v 65)) 20))))
563                  (defun bhf (v)   (/ 1.0    (+ 1.0 (exp (/ (neg (+ v 35)) 10)))))
564                  (defun anf (v)   (* 0.01   (/ (+ v 55) (- 1 (exp (/ (neg (+ v 55)) 10))))))
565                  (defun bnf (v)   (* 0.125  (exp (/ (neg (+ v 65)) 80))))
566
567                  ;; transition rates at current step
568                  (am = (amf v))
569                  (an = (anf v))
570                  (ah = (ahf v))
571                  (bm = (bmf v))
572                  (bn = (bnf v))
573                  (bh = (bhf v))
574
575                  (g_Na = (* gbar_Na  (* h (pow m 3))))
576                  (g_K  = (* gbar_K   (pow n 4)))
577
578                  ;; currents
579                  (I_Na   = (* (- v E_Na) g_Na))
580                  (I_K    = (* (- v E_K)  g_K))
581                  (I_L    = (* g_L  (- v E_L)))
582
583
584                  ;; state equations
585                  (d (m)  = (- (* am (- 1 m))  (* bm m)))
586                  (d (h)  = (- (* ah (- 1 h))  (* bh h)))
587                  (d (n)  = (- (* an (- 1 n))  (* bn n)))
588                  (d (v)  = (/ (- Istim I_L I_Na I_K) C_m))
589                 
590                  (print ((value t)  (value v) 
591                          (value g_Na)  (value I_Na) (value g_K) (value I_K) 
592                          (value am) (value bm) (value ah) (value bh)
593                          (value an) (value bn)
594                          (value n))))
595
596(let ((hh1 (ode:waveform-transformer hodgkin-huxley)))
597  (((ode 'step!) hh1) ode:rkf45 0.0 40.0)))
598EOF
599))
600
601
602(subsection "Hodgkin-Huxley Dynamics as Rate Equations"
603 (pre #<<EOF
604
605;;
606;; This model is the deterministic variant of:
607;;
608;; _Ion Channel Stochasticity May Be Critical in Determining the
609;; Reliability and Precision of Spike Timing_
610;;
611;; Elad Schneidman, Barry Freedman, and Idan Segev
612;;
613;; Neural Computation 10, 1679-1703 (1998)
614;;
615
616(require-extension ode-macros)
617(require-extension ode-rkf45)
618(require-extension ode-rate)
619(require-extension format-graph)
620
621(define format-graph (make-format-graph 'vcg))
622
623(with-ode-system schneidman98
624                 (;; model states
625                  (state v = -65)
626
627                  ;; external inputs to the model
628                  (const I_src = 10)
629
630                  ;; model parameters
631                  (const C_m      = 1)    ;; Specific membrane capacitance, 1 uF/cm^2
632                  (const T        = 6.3)  ;; Temperature, degC
633
634                  (const E_Na     = 115)  ;; Sodium reversal potential, mV
635                  (const E_K      = -12)  ;; Potassium reversal potential, mV
636                  (const E_L      = 10.6) ;; Leakage reversal potential, mV
637
638                  (const gamma_Na = 20)   ;; Sodium channel conductance, pS
639                  (const gamma_K  = 20)   ;; Potassium channel conductance, pS
640
641                  (const gbar_Na  = 120)   ;; Maximal sodium conductance, mS/cm^2
642                  (const gbar_K   = 36)    ;; Maximal potassium conductance, mS/cm^2
643                  (const g_L      = 0.3)   ;; Leakage conductance
644
645                  (const D_Na     = 60)   ;; Sodium ion channel density, channels/um^2
646                  (const D_K      = 18)   ;; Potassium ion channel density, channels/um^2
647                  (const Area     = 200)  ;; Patch area, um^2
648
649                  ;; total number of K channels
650                  (const n_K  = (* Area D_K))
651                  ;; total number of Na channels
652                  (const n_Na = (* Area D_Na))
653
654                  (const i_n0 = (* n_K 0.2))
655                  (const i_n1 = (* n_K 0.2))
656                  (const i_n2 = (* n_K 0.2))
657                  (const i_n3 = (* n_K 0.2))
658                  (const i_n4 = (* n_K 0.2))
659
660                  (state n0 = i_n0)
661                  (state n1 = i_n1)
662                  (state n2 = i_n2)
663                  (state n3 = i_n3)
664                  (state n4 = i_n4)
665
666                  (const i_m0h0 = (* n_Na 0.47))
667                  (const i_m1h0 = (* n_Na 0.01))
668                  (const i_m2h0 = (* n_Na 0.01))
669                  (const i_m3h0 = (* n_Na 0.01))
670                  (const i_m0h1 = (* n_Na 0.47))
671                  (const i_m1h1 = (* n_Na 0.01))
672                  (const i_m2h1 = (* n_Na 0.01))
673                  (const i_m3h1 = (* n_Na 0.01))
674
675                  (state m0h0 = i_m0h0)
676                  (state m1h0 = i_m1h0)
677                  (state m2h0 = i_m2h0)
678                  (state m3h0 = i_m3h0)
679                  (state m0h1 = i_m0h1)
680                  (state m1h1 = i_m1h1)
681                  (state m2h1 = i_m2h1)
682                  (state m3h1 = i_m3h1)
683
684                  ;; rate functions
685                  (defun anf (v)   (* 0.01   (/ (- 10 v)  (- (exp (/ (- 10 v) 10)) 1))))
686                  (defun bnf (v)   (* 0.125  (exp (neg (/ v 80)))))
687                  (defun amf (v)   (* 0.1    (/ (- 25 v)  (- (exp (/ (- 25 v) 10)) 1))))
688                  (defun bmf (v)   (* 4.0    (exp (neg (/ v 18)))))
689                  (defun ahf (v)   (* 0.07   (exp (/ (neg v) 20))))
690                  (defun bhf (v)   (/ 1.0    (+ 1 (exp (/ (- 30 v) 10)))))
691
692                  ;; transition rates at current step
693                  (am = (amf v))
694                  (an = (anf v))
695                  (ah = (ahf v))
696                  (bm = (bmf v))
697                  (bn = (bnf v))
698                  (bh = (bhf v))
699
700                  ;; Transition rates for the K channels, according to
701                  ;; the following kinetic scheme:
702                  ;;
703                  ;; [n0] <-> [n1] <-> [n2] <-> [n3] <-> [n4]
704                  ;;
705                  (rate (-> n0 n1 (* 4 an))
706                        (-> n1 n2 (* 3 an))
707                        (-> n2 n3 (* 2 an))
708                        (-> n3 n4 (* 1 an))
709                        (-> n1 n0 (* 1 bn))
710                        (-> n2 n1 (* 2 bn))
711                        (-> n3 n2 (* 3 bn))
712                        (-> n4 n3 (* 4 bn)))
713
714                   ;; check that the total # of K channels remains
715                   ;; constant
716                   (guard (= n_K (round (+ n0 n1 n2 n3 n4))))
717
718                   ;; check that we have a positive # of K channels in
719                   ;; each state
720                   (guards  (> n0 0.0)
721                            (> n1 0.0)
722                            (> n2 0.0)
723                            (> n3 0.0)
724                            (> n4 0.0))
725
726                   ;; Transition rates for the Na channels,
727                   ;; according to the following kinetic scheme:
728                   ;;
729                   ;; [m0h1] <-> [m1h1] <-> [m2h1] <-> [m3h1]
730                   ;;   /\         /\         /\         /\ 
731                   ;;   ||         ||         ||         || 
732                   ;;   \/         \/         \/         \/ 
733                   ;; [m0h0] <-> [m1h0] <-> [m2h0] <-> [m3h0]
734                   ;;
735                  (rate ;; transitions in row h1
736                        (-> m0h1 m1h1 (* 3 am))
737                        (-> m1h1 m2h1 (* 2 am))
738                        (-> m2h1 m3h1 am)
739                        (-> m1h1 m0h1 bm)
740                        (-> m2h1 m1h1 (* 2 bm))
741                        (-> m3h1 m2h1 (* 3 bm))
742                        ;; transitions in row h0
743                        (-> m0h0 m1h0 (* 3 am))
744                        (-> m1h0 m2h0 (* 2 am))
745                        (-> m2h0 m3h0 am)
746                        (-> m1h0 m0h0 bm)
747                        (-> m2h0 m1h0 (* 2 bm))
748                        (-> m3h0 m2h0 (* 3 bm))
749                        ;; transitions between rows
750                        (-> m0h1 m0h0 bh)
751                        (-> m1h1 m1h0 bh)
752                        (-> m2h1 m2h0 bh)
753                        (-> m3h1 m3h0 bh)
754                        (-> m0h0 m0h1 ah)
755                        (-> m1h0 m1h1 ah)
756                        (-> m2h0 m2h1 ah)
757                        (-> m3h0 m3h1 ah))
758                 
759                 
760
761                   ;; check that the total # of Na channels remains
762                   ;; constant
763                   (guard (= n_Na (round (+ m0h0 m1h0 m2h0 m3h0 m0h1 m1h1 m2h1 m3h1))))
764                                   
765                   ;; check that we have a positive # of Na channels in
766                   ;; each state
767                   (guards  (> m0h0 0.0)
768                            (> m1h0 0.0)
769                            (> m2h0 0.0)
770                            (> m3h0 0.0)
771                            (> m0h1 0.0)
772                            (> m1h1 0.0)
773                            (> m2h1 0.0)
774                            (> m3h1 0.0))
775
776                   ;; Potassium and sodium membrane conductances as
777                   ;; functions of V and t
778                   (g_K   = (* gamma_K   (/ n4 Area)))
779                   (g_Na  = (* gamma_Na  (/ m3h1 Area)))
780
781                   (I_Na   = (* g_Na (- v E_Na)))
782                   (I_K    = (* g_K  (- v E_K)))
783                   (I_L    = (* g_L  (- v E_L)))
784                   (I_stim = (* 1.0 I_src))
785                   
786                   (d (v)  = (/ (- I_stim I_L I_Na I_K) C_m))
787                 
788                  (print ((value t) (value v)
789                          (value g_K) (value I_K) (value g_Na) (value I_Na)
790                          (value an) (value bn) (value am) (value bm) 
791                          (value n0) (value n1) (value n2) (value n3) (value n4)
792                          (value m0h0) (value m1h0) (value m2h0) (value m3h0) 
793                          (value m0h1) (value m1h1) (value m2h1) (value m3h1))) )
794
795  (with-output-to-file "schneidman98.vcg"
796    ;; output the equation dependency graph
797    (lambda () (format-graph (current-output-port) ((ode 'depgraph) schneidman98))))
798   (let ((schneidman98-1 (ode:rate-transformer schneidman98)))
799     ;; run the numerical integrator for the specified length of time
800     (((ode 'step!) schneidman98-1) ode:rkf45 0.0 250.0 0.01)))
801EOF
802))
803
804
805(subsection "Crustacean Stomatogastric Ganglion (STG) Model"
806 (pre #<<EOF
807;;
808;; This model is the deterministic variant of:
809;;
810;; _ Whole Cell Stochastic Model Reproduces the Irregularities Found
811;; in the Membrane Potential of Bursting Neurons_
812;;
813;; Pedro V. Carelli, Marcelo B. Reyes, Jose C. Sartorelli, and Reynaldo D. Pinto
814;;
815;; J Neurophysiol 94: 1169 1179, 2005.
816;;
817
818
819(require-extension ode-macros)
820(require-extension ode-euler)
821(require-extension ode-hhs)
822(require-extension format-graph)
823
824(define format-graph (make-format-graph 'vcg))
825
826(with-ode-system carelli05
827                 (;; membrane potential
828                  (state v  = -65)
829
830                  ;; Ca2+ concentration, uM
831                  (const Ca0 = 0.5)
832                  (state Ca  = Ca0)
833                  (const f   = 14.96) ;; uM/nA
834                  (const tau_Ca = 200) ;; ms
835                 
836                  ;; external inputs to the model
837                  (const I_src = 20)
838
839                  ;; model parameters
840                  (const C_m      = 1)    ;; Specific membrane capacitance, uF/cm^2
841
842                  (const Area = (* 0.628 1e-3)) ;; Membrane area, cm^2
843
844                  ;; Reversal potentials, mV
845                  (const E_Na     = 50)
846                  (const E_Kd     = -80)
847                  (const E_KCa    = -80)
848                  (const E_A      = -80)
849                  (const E_L      = -50) 
850                  (const E_H      = -20)
851
852                  ;; Ionic conductances, mS/cm^2
853
854                  (const g_L      = 0.01)
855
856                  (ionic conductance (Na
857                                      (gbar  200)
858                                      (gamma 3) 
859                                      (delta 1)
860                                      (initial-m 0.9) 
861                                      (initial-h 0.1)
862                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 25.5) -5.29)))))
863                                      (hinf  (/ 1 (+ 1 (exp (/ (+ v 48.9) 5.18)))))
864                                      (taum  (- 2.64 (/ 2.52 (+ 1 (exp (/ (+ v 120) -25))))))
865                                      (tauh  (* (/ 1.34 (+ 1 (exp (/ (+ v 62.9) -10))))
866                                                (+ 1.5 (/ 1 (+ 1 (exp (/ (+ v 34.9) 3.6)))))))))
867
868
869                  (ionic conductance (CaT
870                                      (gbar 2.5)
871                                      (gamma 3) 
872                                      (delta 1)
873                                      (initial-m 0.1) 
874                                      (initial-h 0.1)
875                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 27.1) -7.2)))))
876                                      (hinf  (/ 1 (+ 1 (exp (/ (+ v 32.1) 5.5)))))
877                                      (taum  (- 43.4 (/ 42.6 (+ 1 (exp (/ (+ v 68.1) -20.5))))))
878                                      (tauh  (- 210  (/ 179.6 (+ 1 (exp (/ (+ v 55) -16.9))))))))
879
880
881                  (ionic conductance (CaS
882                                      (gbar  4)
883                                      (gamma 3) 
884                                      (delta 1)
885                                      (initial-m 0.1) 
886                                      (initial-h 0.1)
887                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 33) -8.1)))))
888                                      (hinf  (/ 1 (+ 1 (exp (/ (+ v 60) 6.2)))))
889                                      (taum  (+ 2.8  (/ 14  (+ (exp (/ (+ v 27) 10)) (exp (/ (+ v 70) -13))))))
890                                      (tauh  (+ 120  (/ 300 (+ (exp (/ (+ v 55) 9)) (exp (/ (+ v 65) -16))))))))
891
892                  (ionic conductance (A
893                                      (gbar 50)
894                                      (gamma 3) 
895                                      (delta 1)
896                                      (initial-m 0.1) 
897                                      (initial-h 0.1)
898                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 27.2) -8.7)))))
899                                      (hinf  (/ 1 (+ 1 (exp (/ (+ v 56.9) 4.9)))))
900                                      (taum  (- 23.2 (/ 20.8 (+ 1 (exp (/ (+ v 32.9) -15.2))))))
901                                      (tauh  (- 77.2  (/ 58.4 (+ 1 (exp (/ (+ v 38.9) -26.5))))))))
902
903                  ;; In cases where delta=0, there is no inactivation,
904                  ;; and therefore the h expressions are omitted
905
906                  (ionic conductance (KCa
907                                      (gbar  5)
908                                      (gamma 4) 
909                                      (delta 0)
910                                      (initial-m 0.1) 
911                                      (minf  (* (/ Ca (+ 3 Ca)) (/ 1 (+ 1 (exp (/ (+ v 28.3) -12.6))))))
912                                      (taum  (- 180.6 (/ 150.2 (+ 1 (exp (/ (+ v 46) -22.7))))))))
913
914                 
915                  (ionic conductance (Kd
916                                      (gbar 100)
917                                      (gamma 4) 
918                                      (delta 0)
919                                      (initial-m 0.1) 
920                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 12.3) -11.8)))))
921                                      (taum  (- 14.4  (/ 12.8  (exp (/ (+ v 28.3) -19.2)))))))
922
923                 
924                  (ionic conductance (H
925                                      (gbar 0.01)
926                                      (gamma 1) 
927                                      (delta 0)
928                                      (initial-m 0.1) 
929                                      (minf  (/ 1 (+ 1 (exp (/ (+ v 75) 5.5)))))
930                                      (taum  (/ 2.2 (+ (exp (/ (+ v 169.7) -11.6)) (exp (/ (- v 26.7) 14.3)))))))
931
932                  ;; Assuming external Ca2+ concentration of 3000 uM
933                  (E_Ca = (* 12.5  (ln (/ 3000 Ca))))
934                 
935                  ;; Ionic currents
936                  (I_Na   = (* g_Na  (- v E_Na)))
937                  (I_CaT  = (* g_CaT (- v E_Ca)))
938                  (I_CaS  = (* g_CaS (- v E_Ca)))
939                  (I_A    = (* g_A   (- v E_A)))
940                  (I_KCa  = (* g_KCa (- v E_KCa)))
941                  (I_Kd   = (* g_Kd  (- v E_Kd)))
942                  (I_H    = (* g_H   (- v E_H)))
943                  (I_L    = (* g_L   (- v E_L)))
944
945                  ;; stimulus current
946                  (I_stim = I_src)
947
948
949                  ;; Calcium buffer
950                  (d (Ca) = (* (neg (/ 1 tau_Ca)) (+ (* f (+ I_CaT I_CaS)) Ca (neg Ca0))))
951                 
952                  (d (v)  = (/ (- I_stim I_L I_Na I_CaT I_CaS I_A I_KCa I_Kd I_H) C_m))
953
954                 
955                  (print ((value t) (value v) (value I_stim))) )
956
957  (let ((carelli05-1 (ode:hhs-transformer carelli05)))
958    (with-output-to-file "carelli05.vcg"
959      ;; output the equation dependency graph
960      (lambda () (format-graph (current-output-port) ((ode 'depgraph) carelli05-1))))
961    ;; run the numerical integrator for the specified length of time
962    (((ode 'step!)  carelli05-1) ode:euler 0.0 500.0 5e-3)))
963EOF
964)))
965
966
967
968
969     (license
970      "Copyright 2007 Ivan Raikov and the Okinawa Institute of Science and Technology
971
972This program is free software: you can redistribute it and/or modify
973it under the terms of the GNU General Public License as published by
974the Free Software Foundation, either version 3 of the License, or (at
975your option) any later version.
976
977This program is distributed in the hope that it will be useful, but
978WITHOUT ANY WARRANTY; without even the implied warranty of
979MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
980General Public License for more details.
981
982A full copy of the GPL license can be found at
983<http://www.gnu.org/licenses/>."))))
984
985
986(define ode-eggdoc:css (make-parameter #<<EOF
987 <!--
988      CODE {
989            color: #666666;
990          }
991/*   DT.definition EM { font-weight: bold; font-style: normal; } */
992
993     DT.definition { 
994                   background: #eee;
995                   color: black;
996                   padding: 0.2em 1em 0.2em 0.7em;
997                   margin-left: 0.2em;
998border: 1px solid #bbc;
999                   font-family: "Andale Mono", monospace;
1000                   /* font-size: 1.2em; */
1001                   
1002                 }
1003     DD {
1004                   margin-top: 0.8em;
1005                   margin-bottom: 0.8em;
1006     }
1007     DIV.subsection {
1008                    border-top: 1px solid #448;
1009                    padding-left: 1em;
1010                    margin-bottom: 1.2em;
1011     }
1012     DIV.subsubsection {
1013                    border-top: 1px dotted #99c;
1014                    /* border-left: 1px solid #99c; */
1015                    padding-left: 1em;
1016                    margin-bottom: 1.2em;
1017     }
1018     DIV.subsubsubsection {
1019                    border-top: 1px solid #ddf;
1020                    padding-left: 1em;
1021                    margin-bottom: 1.2em;
1022     }
1023
1024         DIV.section {
1025                 margin-bottom: 1.5em;
1026         }
1027         a:link {
1028                 color: #336;
1029         }
1030         a:visited { color: #666; }
1031         a:active  { color: #966; }
1032         a:hover   { color: #669; }
1033         body { margin: 0; padding: 0; background: #fff; color: #000; font: 9pt "Lucida Grande", "Verdana", sans-serif; }
1034         H2 {
1035                 background: #336;
1036                 color: #fff;
1037                 padding-top: 0.5em;
1038                 padding-bottom: 0.5em;
1039                 padding-left: 16px;
1040                 margin: 0 0 1em 0;
1041        }
1042        UL LI {
1043                list-style: none;
1044        }
1045        TT {
1046                font-family: "Andale Mono", monospace;
1047                /* font-size: 1.2em; */
1048        }
1049        H3 {
1050                color: #113;
1051                margin-bottom: 0.5em;
1052        }
1053        H4, H5, H6 {
1054                color: #113;
1055                margin-bottom: 1.0em;
1056        }
1057        H5 {
1058                font-weight: normal;
1059                font-style: italic;
1060                font-size: 100%;
1061                margin-top: 1.2em;
1062        }
1063        H6 {
1064                font-weight: bold;
1065                font-size: 85%;
1066                margin-top: 1.2em;
1067        }
1068     DIV#eggheader {
1069         text-align: center;
1070                 float: right;
1071                 margin-right: 2em;
1072     }
1073     DIV#header IMG {
1074            /* display: block; margin-left: auto; margin-right: auto;  */
1075            /* float: right; */
1076            border: none;  /* firefox */
1077     }
1078     DIV#footer {
1079                background: #bbd;
1080                padding: 0.7em ;
1081                border-top: 1px solid #cce;
1082     }
1083     DIV#footer hr {
1084                display: none;
1085     }
1086     DIV#footer a {
1087                float: left;
1088     }
1089     DIV#revision-history {
1090         float: right;
1091     }
1092     
1093     DIV#body {
1094                 margin: 1em 1em 1em 16px;
1095         }
1096
1097     DIV#examples PRE {
1098       background: #eef;
1099       padding: 0.1em;
1100       border: 1px solid #aac;
1101     }
1102     PRE#license, DIV#examples PRE {
1103       padding: 0.5em;
1104     }
1105     DIV#examples PRE {
1106       /* font-size: 85%; */
1107     }
1108     PRE { font-family: "Andale Mono", monospace; }
1109     TABLE {
1110       background: #eef;
1111       padding: 0.2em;
1112       border: 1px solid #aac;
1113       border-collapse: collapse;
1114       width: 100%;
1115     }
1116     TABLE.symbol-table TD.symbol {
1117          width: 15em;
1118          font-family: "Andale Mono", monospace;
1119          vertical-align: top;
1120          /* font-size: 1.2em; */
1121     }
1122     TABLE.symbol-table TD {
1123          font-family: "Andale Mono", monospace;
1124          vertical-align: top;
1125          /* font-size: 1.2em; */
1126     }
1127     TH {
1128       text-align: left;
1129       border-bottom: 1px solid #aac;
1130       padding: 0.25em 0.5em 0.25em 0.5em;
1131     } 
1132     TD { padding: 0.25em 0.5em 0.25em 0.5em; }
1133     -->
1134EOF
1135))
1136
1137
1138(if (eggdoc->html doc 
1139                   `( (eggdoc-style . ,(lambda (tag)
1140                         `("<style type=\"text/css\">" ,(ode-eggdoc:css)
1141                           "</style>")))
1142                      (documentation *macro* . ,(lambda (tag . elts)
1143                        (let* ((sections
1144                                (pre-post-order elts
1145                                                `((subsection   ;; (subsection level "content ...")
1146                                                   ((*text* . ,(lambda (tag str) str)))
1147                                                   . ,(lambda (tag head-word . elems)
1148                                                        `(li (a (@ (href ,(string-append "#" head-word)))
1149                                                                ,head-word))))
1150                                                  (*default*
1151                                                   . ,(lambda (tag . elems) (list)))
1152                                                 
1153                                                  (*text* . ,(lambda (trigger str) (list))))))
1154                               (toc `(div (@ (class "toc"))
1155                                          (ol ,sections))))
1156                          `(section "Documentation" ,(cons toc elts)))))
1157                      ,@(eggdoc:make-stylesheet doc) ))
1158
1159    (void))
Note: See TracBrowser for help on using the repository browser.