TODO.org

   1 #+TODO: TODO CURR | DONE
   2 #+TODO: CANCELED
   3
   4
   5 Time-stamp: <2012-10-08 05:26:30 tony>
   6 Creation:   <2008-09-08 08:06:30 tony>
   7
   8 * Intro and Metadata
   9
  10 File:       TODO.lisp
  11 Author:     AJ Rossini <blindglobe@gmail.com>
  12 Copyright:  (c) 2007-2010, AJ Rossini <blindglobe@gmail.com>.  BSD.
  13 Purpose:    Stuff that needs to be made working sits inside the
  14             Task sections.
  15
  16             This file contains the current challenges to solve,
  17             including a description of the setup and the work to
  18             solve.  Solutions welcome.
  19
  20 What is this talk of 'release'? Klingons do not make software
  21 'releases'.  Our software 'escapes', leaving a bloody trail of
  22 designers and quality assurance people in its wake.
  23
  24 * Design Documentation
  25
  26 This section provides some of the details regarding infrastructure of
  27 the system, as a means of including TODO statements.
  28
  29 ** (Internal) Package and (External) System Hierarchy
  30
  31 current (possibly incomplete) set of lisp dependencies <2012-10-04 Thu>
  32
  33  0  ~/sandbox/xarray.git
  34  1  ~/sandbox/foreign-numeric-vector.git
  35  2  ~/sandbox/trivial-features.git
  36  3  ~/sandbox/alexandria.git
  37  4  ~/sandbox/babel.git
  38  5  ~/sandbox/cffi.git
  39  6  ~/sandbox/cl-utilities
  40  7  ~/sandbox/metabang-bind.git
  41  8  ~/sandbox/iterate.git
  42  9  ~/sandbox/array-operations.git
  43
  44
  45 *** Singletons (primary building blocks)
  46
  47     These are packages as well as
  48
  49     | asdf          | common system loader                          |
  50     | xarray        | common access structure to array-like         |
  51     |               | (matrix, vector) structures.                  |
  52     | cls-config    | initialization of Lisp state, variables, etc, |
  53     |               | localization to the particular lisp.          |
  54     | lift          | unit-testing                                  |
  55     | cffi          | foriegn function library                      |
  56     | alexandria    |                                               |
  57     | babel         |                                               |
  58     | iterate       |                                               |
  59     | metabang-bind |                                               |
  60
  61     as of now, all are in QL heirarchy
  62
  63 *** Dependency structure
  64
  65     | lisp-matrix     | general purpose matrix package, linking to lapack |      |
  66     |                 | for numerics. Depends on:                         |      |
  67     |                 | ffa                                               | cffi |
  68     |                 | fnv                                               | cffi |
  69     |                 | cl-blapack                                        | cffi |
  70     |                 | xarray                                            |      |
  71     | cls-dataframe   | in the same spirit as lisp-matrix, a means to     |      |
  72     |                 | create tables.  Perhaps better called datatables? |      |
  73     | cls-probability | depends on gsll, cl-variates, cl-? initially,     |      |
  74
  75 *** Need to integrate
  76
  77 **** Random number streams and probability calculus
  78
  79
  80      Something for random numbers, that has a settable seed.  However,
  81      we could pass on the "right thing" in favor of something that
  82      will "work for now".
  83      cl-randist
  84
  85 **** import of data in text files
  86
  87      CSV and similar specialized imports
  88
  89      rsm-string
  90
  91 **** Graphics
  92
  93      ?? cl-2d  :
  94                cl-cairo2 : cffi
  95
  96      ?? cl-plplot : cffi
  97
  98
  99 * Tasks to Do [2/26]
 100
 101   Usually, we need to load it everything before going on.
 102
 103 #+name: loadit
 104 #+begin_src lisp
 105   (ql:quickload :cls)
 106 #+end_src
 107
 108 #+RESULTS: loadit
 109 | :CLS |
 110
 111   and sometimes we might want to recompile fully:
 112
 113 #+name: recompile-it-all
 114 #+begin_src lisp
 115   (asdf:oos 'asdf:compile-op :cls :force T)
 116 #+end_src
 117
 118   Currently QuickLisp support doesn't provide a recompilation
 119   facility.  And QL is built over and partially extends ASDF, so we
 120   should be fine for now.
 121
 122 ** DONE [#B] SET UP
 123    - State "DONE"       from "CURR"       [2010-10-12 Tue 13:48] \\
 124      setup is mostly complete
 125    - State "CURR"       from "TODO"       [2010-10-12 Tue 13:47]
 126    - State "TODO"       from ""           [2010-10-12 Tue 13:47]
 127
 128    This is an example of a custom setup, not really interesting at
 129    this point (it's obsolete) except to remind Tony how to program.
 130    Pointy-headed managers need any support they can find in order to
 131    regress to their hacker-childhood.
 132
 133    The only point of this section is to illustrate that we could want
 134    to load additional modules that are not a central part of the core
 135    files.
 136
 137 #+name: CustomLoader
 138 #+begin_src lisp :tangle "examples/CustomLoader.lisp
 139   (in-package :cl-user) ; always ensure we are in the right package to leave droppings and access functionality
 140   (progn
 141     (defun init-CLS (&key (compile 'nil))
 142       (let ((packagesToLoad (list ;; core system
 143                                   :lift :lisp-matrix :cls
 144                                   ;; visualization
 145                                   ;; :cl-cairo2-x11 :iterate
 146                                   :cl-2d
 147                                   ;; doc reporting
 148                                   :cl-pdf :cl-typesetting
 149                                   ;;INFRA
 150                                   :asdf-system-connections :xarray
 151                                   ;;DOCS
 152                                   :metatilities-base :anaphora :tinaa
 153                                   :cl-ppcre :cl-markdown :docudown
 154                                   ;; version and validate CLOS objects
 155                                   ;; :versioned-objects :validations
 156                                   ;;VIZ
 157                                   ;; :cl-opengl
 158                                   ;; :cl-glu :cl-glut :cl-glut-examples
 159
 160
 161                                   ;; :cells :cells-gtk
 162                                   :bordeaux-threads)))
 163         (mapcar #'(lambda (x)
 164                     (if compile
 165                         (asdf:oos 'asdf:compile-op x :force T)
 166                         (asdf:oos 'asdf:load-op x)))
 167                 packagesToLoad)))
 168
 169     (init-CLS)) ;; vs (init-CLS :compile T)
 170 #+end_src
 171
 172 #+results:
 173 |   | #<PACKAGE "COMMON-LISP-USER"> |
 174
 175 ** CURR [#A] Integrate with quicklist support.
 176
 177    important to merge with quicklisp system loader support.  We
 178    currently have some of this work integrated, but I think there are
 179    a few systems which are not auto-installable.
 180
 181
 182 ** CURR [#A] Testing: unit, regression, examples. [0/3]
 183    - State "CURR"       from "TODO"       [2010-10-12 Tue 13:51]
 184    - State "TODO"       from ""           [2010-10-12 Tue 13:51]
 185    Testing consists of unit tests, which internally verify subsets of
 186    code, regression tests, and functional tests (in increasing order
 187    of scale).
 188 *** CURR [#B] Unit tests
 189     - State "CURR"       from "TODO"       [2010-11-04 Thu 18:33]
 190    - State "CURR"       from "TODO"       [2010-10-12 Tue 13:48]
 191    - State "TODO"       from ""           [2010-10-12 Tue 13:48]
 192    Unit tests have been started using LIFT.  Need to consider some of
 193    the other systems that provide testing, when people add them to the
 194    mix of libraries that we need, along with examples of how to use.
 195
 196 #+name: ex-cls-unittest
 197 #+begin_src lisp
 198   (in-package :lisp-stat-unittests)
 199   (run-tests :suite 'lisp-stat-ut)
 200 #+end_src
 201
 202 #+results:
 203 : #<Results for LISP-STAT-UT 78 Tests, 7 Failures, 20 Errors>
 204
 205   ;; => tests = 78, failures = 7, errors = 20
 206
 207
 208
 209 The following needs to be solved in order to have a decent
 210 installation qualification (IQ) and performance qualification (PQ)
 211
 212 #+name: cls-unittest
 213 #+begin_src lisp
 214   (in-package :lisp-stat-unittests)
 215   (asdf:oos 'asdf:test-op 'cls)
 216   ;; which runs (describe (run-tests :suite 'lisp-stat-ut))
 217 #+end_src
 218
 219
 220
 221    and check documentation to see if it is useful.
 222 #+name: unittest-ex
 223 #+begin_src lisp
 224    (in-package :lisp-stat-unittests)
 225
 226    (describe 'lisp-stat-ut)
 227    (documentation 'lisp-stat-ut 'type)
 228
 229    ;; FIXME: Example: currently not relevant, yet
 230    ;;   (describe (lift::run-test :test-case  'lisp-stat-unittests::create-proto
 231    ;;                             :suite 'lisp-stat-unittests::lisp-stat-ut-proto))
 232
 233    (describe (lift::run-tests :suite 'lisp-stat-ut-dataframe))
 234    (lift::run-tests :suite 'lisp-stat-ut-dataframe)
 235
 236    (describe (lift::run-test
 237                :test-case  'lisp-stat-unittests::create-proto
 238                :suite 'lisp-stat-unittests::lisp-stat-ut-proto))
 239 #+end_src
 240
 241 *** TODO [#B] Regression Tests
 242     - State "TODO"       from ""           [2010-10-12 Tue 13:54]
 243
 244 *** TODO [#B] Functional Tests
 245     - State "TODO"       from ""           [2010-10-12 Tue 13:54]
 246
 247 ** CURR [#B] Functional Examples that need to work [1/3]
 248    - State "CURR"       from "TODO"       [2010-11-30 Tue 17:57]
 249    - State "TODO"       from ""           [2010-10-12 Tue 13:55]
 250
 251    These examples should be functional forms within CLS, describing
 252    working functionality which is needed for work.
 253 *** TODO [#A] Dataframe creation
 254     Illustration via a file, that we need to get working so that we
 255     can get data in-and-out of CLS structures.
 256
 257 #+BEGIN_SRC lisp :export examples/example-DF-creation.lisp
 258   ;;; -*- mode: lisp -*-
 259   ;;; Copyright (c) 2006-2012, by A.J. Rossini <blindglobe@gmail.com>
 260   ;;; See COPYRIGHT file for any additional restrictions (BSD license).
 261   ;;; Since 1991, ANSI was finally finished.  Edited for ANSI Common Lisp.
 262
 263   ;;; Time-stamp: <2012-10-04 02:16:45 tony>
 264   ;;; Creation:   <2012-07-01 11:29:42 tony>
 265   ;;; File:       example.lisp
 266   ;;; Author:     AJ Rossini <blindglobe@gmail.com>
 267   ;;; Copyright:  (c) 2012, AJ Rossini.  BSD.
 268   ;;; Purpose:    example of possible usage.
 269
 270   ;;; What is this talk of 'release'? Klingons do not make software
 271   ;;; 'releases'.  Our software 'escapes', leaving a bloody trail of
 272   ;;; designers and quality assurance people in its wake.
 273
 274
 275   ;; Load system
 276   (ql:quickload "cls")
 277
 278   ;; use the example package...
 279   (in-package :cls-user)
 280
 281
 282   ;; or better yet, create a package/namespace for the particular problem being attacked.
 283   (defpackage :my-package-user
 284     (:documentation "demo of how to put serious work should be placed in
 285       a similar package elsewhere for reproducibility.  This hints as to
 286       what needs to be done for a user- or analysis-package.")
 287     (:nicknames :my-clswork-user)
 288     (:use :common-lisp ; always needed for user playgrounds!
 289           :lisp-matrix ; we only need the packages that we need...
 290           :common-lisp-statistics
 291           :lisp-stat-data-examples) ;; this ensures access to a data package
 292     (:export summarize-data summarize-results this-data this-report)
 293     (:shadowing-import-from :lisp-stat call-method call-next-method
 294
 295         expt + - * / ** mod rem abs 1+ 1- log exp sqrt sin cos tan
 296         asin acos atan sinh cosh tanh asinh acosh atanh float random
 297         truncate floor ceiling round minusp zerop plusp evenp oddp
 298         < <= = /= >= > > ;; complex
 299         conjugate realpart imagpart phase
 300         min max logand logior logxor lognot ffloor fceiling
 301         ftruncate fround signum cis
 302
 303         <= float imagpart))
 304
 305   (in-package :my-clswork-user)
 306
 307   ;; create some data by hand using arrays, and demonstrate access.
 308
 309   (let ((myArray #2A((1 2 3)(4 5 6)))
 310         (myDF    (make-dataframe #2A((1 2 3)(4 5 6))))
 311         (myLOL   (list (list 1 2 3) (list 4 5 6)))
 312         ;; FIXME: listoflist conversion does not work.
 313         ;; (myDFlol (make-dataframe  '(list ((1 2 3)(4 5 6)))))
 314         )
 315
 316     (= (xref myArray 1 1)
 317        (xref myDF    1 1)
 318        (xref myLOL   1 1)))
 319
 320 #+END_SRC
 321 *** TODO [#B] Scoping with datasets
 322     - State "TODO"       from ""           [2010-11-04 Thu 18:46]
 323
 324     The following needs to work, and a related syntax for resampling
 325     and similar synthetic data approaches (bootstrapping, imputation)
 326     ought to use similar syntax as well.
 327 #+name: DataSetNameScoping
 328 #+begin_src lisp
 329   (in-package :ls-user)
 330   (progn
 331     ;; Syntax examples using lexical scope, closures, and bindings to
 332     ;; ensure a clean communication of results
 333     ;; This is actually a bit tricky, since we need to clarify whether
 334     ;; it is line-at-a-time that we are considering or if there is
 335     ;; another mapping strategy.  In particular, one could imagine a
 336     ;; looping-over-observations function, or a
 337     ;; looping-over-independent-observations function which leverages a
 338     ;; grouping variable which provides guidance for what is considered
 339     ;; independent from the sampling frame being considered. The frame
 340     ;; itself (definable via some form of metadata to clarify scope?)
 341     ;; could clearly provide a bit of relativity for clarifying what
 342     ;; statistical independence means.
 343
 344     (with-data dataset ((dsvarname1 [usevarname1])
 345                         (dsvarname2 [usevarname2]))
 346         @body)
 347
 348     ;; SAS-centric approach to spec'ing work
 349     (looping-over-observations
 350        dataset ((dsvarname1 [usevarname1])
 351                 (dsvarname2 [usevarname2]))
 352          @body)
 353
 354     ;; SAS plus "statistical sensibility"... for example, if an
 355     ;; independent observation actually consists of many observations so
 356     ;; that a dataframe of independence results -- for example,
 357     ;; longitudinal data or spatial data or local-truncated network data
 358     ;; are clean examples of such happening -- then we get the data
 359     ;; frame or row representing the independent result.
 360     (looping-over-independent-observations
 361        dataset independence-defining-variable
 362          ((dsvarname1 [usevarname1])
 363           (dsvarname2 [usevarname2]))
 364          @body)
 365     )
 366 #+end_src
 367
 368 *** DONE [#B] Dataframe variable typing
 369     - State "DONE"       from "CURR"       [2010-11-30 Tue 17:56] \\
 370       check-type approach works, we would just have to throw a catchable
 371       error if we want to use it in a reliable fashion.
 372     - State "CURR"       from "TODO"       [2010-11-30 Tue 17:56]
 373     - State "TODO"       from ""           [2010-11-04 Thu 18:48]
 374
 375     Seems to generally work, need to ensure that we use this for
 376     appropriate typing.
 377
 378 #+name: DFvarTyping
 379 #+begin_src lisp
 380   (in-package :ls-user)
 381   (defparameter *df-test*
 382     (make-instance 'dataframe-array
 383                    :storage #2A (('a "test0" 0 0d0)
 384                                  ('b "test1" 1 1d0)
 385                                  ('c "test2" 2 2d0)
 386                                  ('d "test3" 3 3d0)
 387                                  ('e "test4" 4 4d0))
 388                    :doc "test reality"
 389                    :case-labels (list "0" "1" 2 "3" "4")
 390                    :var-labels (list "symbol" "string" "integer" "double-float")
 391                    :var-types (list 'symbol 'string 'integer 'double-float)))
 392
 393   ;; with SBCL, ints become floats?  Need to adjust output
 394   ;; representation appropriately..
 395   ,*df-test*
 396
 397   (defun check-var (df colnum)
 398     (let ((nobs (xdim (dataset df) 0)))
 399       (dotimes (i nobs)
 400         (check-type (xref df i colnum) (elt (var-types df) i)))))
 401
 402   (xdim (dataset *df-test*) 1)
 403   (xdim (dataset *df-test*) 0)
 404
 405   (check-var *df-test* 0)
 406
 407   (class-of
 408     (xref *df-test* 1 1))
 409
 410   (check-type (xref *df-test* 1 1)
 411               string) ;; => nil, so good.
 412   (check-type (xref *df-test* 1 1)
 413               vector) ;; => nil, so good.
 414   (check-type (xref *df-test* 1 1)
 415               real) ;; => simple-error type thrown, so good.
 416
 417   ;; How to nest errors within errors?
 418   (check-type (check-type (xref *df-test* 1 1) real) ;; => error thrown, so good.
 419               simple-error)
 420   (xref *df-test* 1 2)
 421
 422   (check-type *df-test*
 423               dataframe-array) ; nil is good.
 424
 425   (integerp (xref *df-test* 1 2))
 426   (floatp (xref *df-test* 1 2))
 427   (integerp (xref *df-test* 1 3))
 428   (type-of (xref *df-test* 1 3))
 429   (floatp (xref *df-test* 1 3))
 430
 431   (type-of (vector 1 1d0))
 432   (type-of *df-test*)
 433
 434   (xref *df-test* 2 1)
 435   (xref *df-test* 0 0)
 436   (xref *df-test* 1 0)
 437   (xref *df-test* 1 '*)
 438 #+end_src
 439
 440 ** CURR [#A] Random Numbers [2/6]
 441    - State "CURR"       from "TODO"       [2010-11-05 Fri 15:41]
 442    - State "TODO"       from ""           [2010-10-14 Thu 00:12]
 443
 444    Need to select and choose a probability system (probability
 445    functions, random numbers).  Goal is to have a general framework
 446    for representing probability functions, functionals on
 447    probabilities, and reproducible random streams based on such
 448    numbers.
 449 *** CURR [#B] CL-VARIATES system evaluation [2/3]
 450     - State "CURR"       from "TODO"       [2010-11-05 Fri 15:40]
 451     - State "TODO"       from ""           [2010-10-12 Tue 14:16]
 452
 453     CL-VARIATES is a system developed by Gary W King.  It uses streams
 454     with seeds, and is hence reproducible.  (Random comment: why do CL
 455     programmers as a class ignore computational reproducibility?)
 456
 457     The main problem with this system is licensing.  It has a weird
 458     licensing schema which prevents
 459
 460 #+name: Loading-CL-VARIATES
 461 #+begin_src lisp
 462   (in-package :cl-user)
 463   (ql:quickload :cl-variates)
 464   ;;(ql:quickload :cl-variates-test)
 465 #+end_src
 466
 467 #+name: CL-VARIATES-UNITTESTS
 468 #+begin_src lisp
 469   (in-package :cl-variates-test)
 470   ;; check tests
 471   (run-tests :suite 'cl-variates-test)
 472   (describe (run-tests :suite 'cl-variates-test))
 473 #+end_src
 474
 475     basic example of reproducible draws from the uniform and normal
 476     random number streams.
 477
 478 #+name: CL-VARIATES-REPRO
 479 #+begin_src lisp
 480
 481   (in-package :cl-variates-user)
 482
 483   (defparameter state (make-random-number-generator))
 484   (setf (random-seed state) 44)
 485
 486   (random-seed state)
 487   (loop for i from 1 to 10 collect
 488                     (random-range state 0 10))
 489   ;; => (1 5 1 0 7 1 2 2 8 10)
 490   (setf (random-seed state) 44)
 491   (loop for i from 1 to 10 collect
 492                     (random-range state 0 10))
 493   ;; => (1 5 1 0 7 1 2 2 8 10)
 494
 495   (setf (random-seed state) 44)
 496   (random-seed state)
 497   (loop for i from 1 to 10 collect
 498                     (normal-random state 0 1))
 499   ;; =>
 500   ;; (-1.2968656102820426 0.40746363934173213 -0.8594712469518473 0.8795681301148328
 501   ;;  1.0731526250004264 -0.8161629082481728 0.7001813608754809 0.1078045427044097
 502   ;;  0.20750134211656893 -0.14501914108452274)
 503
 504   (setf (random-seed state) 44)
 505   (loop for i from 1 to 10 collect
 506                     (normal-random state 0 1))
 507   ;; =>
 508   ;; (-1.2968656102820426 0.40746363934173213 -0.8594712469518473 0.8795681301148328
 509   ;;  1.0731526250004264 -0.8161629082481728 0.7001813608754809 0.1078045427044097
 510   ;;  0.20750134211656893 -0.14501914108452274)
 511
 512 #+end_src
 513
 514 **** CURR [#B] Full example of general usage
 515      - State "CURR"       from "TODO"       [2010-11-05 Fri 15:40]
 516      - State "TODO"       from ""           [2010-11-05 Fri 15:40]
 517
 518      What we want to do here is describe the basic available API that
 519      is present.  So while the previous work describes what the basic
 520      reproducibility approach would be in terms of generating lists of
 521      reproducible pRNG streams, we need the full range of possible
 522      probability laws that are present.
 523
 524      One of the good things about cl-variates is that it provides for
 525      reproducibility.  One of the bad things is that it has a mixed
 526      bag for an API.
 527
 528 *** TODO [#B] CL-RANDOM system evaluation
 529     - State "TODO"       from ""           [2010-11-05 Fri 15:40]
 530
 531     Problems:
 532     1. no seed setting for random numbers
 533     2. contamination of a probability support with optimization and
 534        linear algebra.
 535
 536     Positives:
 537     1. good code
 538     2. nice design for generics.
 539
 540 *** TODO [#B] Native CLS (from XLS)
 541     - State "TODO"       from ""           [2010-11-05 Fri 15:40]
 542
 543 ** TODO [#B] Numerical Linear Algebra
 544    - State "TODO"       from ""           [2010-10-14 Thu 00:12]
 545
 546 *** TODO [#B] LLA evaluation
 547     - State "TODO"       from ""           [2010-10-12 Tue 14:13]
 548
 549 LLA is an SBCL targetted linear algebra library from Tamas Papp
 550
 551 #+NAME LLA-experiments
 552 #+BEGIN_SRC lisp
 553 (in-package :cl-user)
 554 (asdf:oos 'asdf:load-op 'lla)
 555 (in-package :lla-user)
 556 ;;; experiment here
 557 #+END_SRC
 558
 559 *** CURR [#B] Lisp-Matrix system evaluation
 560     - State "CURR"       from "TODO"       [2010-10-12 Tue 14:13]
 561     - State "TODO"       from ""           [2010-10-12 Tue 14:13]
 562
 563       in progress
 564
 565 *** TODO [#B] LispLab system evaluation
 566     - State "TODO"       from ""           [2010-10-12 Tue 14:13]
 567
 568 LL is an SBCL targetted linear algebra library from ---
 569
 570 ** TODO [#B] Statistical Procedures to implement
 571    - State "TODO"       from ""           [2010-10-14 Thu 00:12]
 572
 573 *** TODO [#C] PFIM
 574
 575 #+BEGIN_SRC lisp
 576
 577 (in-package :cls-user)
 578 ;;;; PFIM notes
 579
 580 ;; PFIM 3.2
 581
 582 ;; population design eval and opt
 583 #|
 584 issues:
 585 - # individuals
 586 - # sampling times
 587 - sampling times?
 588
 589 constraints:
 590 number of samples/cost of lab analysis and collection
 591 expt constraints
 592 |#
 593
 594 (defun pfim (&key model ( constraints ( summary-function )
 595
 596   (list num-subjects num-times list-times))))
 597
 598 #|
 599 N individuals i
 600 Each individal has a deisgn psi_i
 601    nubmer of samples n_i and sampling times t_{i{1}} t_{i{n_1}}
 602    individuals can differ
 603
 604 Model:
 605
 606 individual-level model
 607 |#
 608
 609 (=model y_i (+ (f \theta_i \psi_i) epsilion_i ))
 610 (=var \epsilion_i \sigma_between \sigma_within  )
 611
 612 ;; Information Matrix for pop deisgn
 613
 614 (defparameter IM (sum  (i 1 N) (MF \psi_i \phi_i)))
 615
 616 #|
 617 For nonlinear structureal models, expand around RE=0
 618
 619 Cramer-Rao : MF^{-1} is lower bound for estimation variance.
 620
 621 Design comparisons:
 622
 623 - smallest SE, but is a matrix, so
 624 - criteria for matrix comparison
 625 -- D-opt, (power (determinant MF) (/ 1 P))
 626
 627
 628 find design maxing D opt, (power (determinant MF) (/ 1 P))
 629 Design varialables
 630  -- contin vars for smapling times within interval or set -- number of groups for cat vars
 631
 632 Stat in Med 2009, expansion around post-hoc RE est, not necessarily zero.
 633
 634 Example binary covariate C
 635 |#
 636
 637 (if (= i reference-class)
 638     (setf (aref C i) 0)
 639     (setf (aref C i) 1))
 640
 641 ;; Exponential RE,
 642 (=model (log \theta) (  ))
 643
 644 ;; extensions
 645
 646 ;; outputs
 647
 648 #|
 649 PFIM provides for a given design and values of \beta:
 650  compute extended FIM
 651  SE/RSE for \beta of each class of each covar
 652  eval influence of design on SE(\beta)
 653
 654 inter-occassion variability (IOV)
 655 - patients sampled more than once, H occassions
 656 - RE for IOV
 657 - additional vars to estimate
 658
 659 |#
 660
 661 ;;; comparison criteria
 662
 663 functional of conc/time curve which is used for comparison, i.e.
 664 (AUC conc/time-curve)
 665 (Cmax conc/time-curve)
 666 (Tmax conc/time-curve)
 667
 668 where
 669
 670 (defun conc/time-curve (t)
 671   ;; computation
 672 #|
 673   (let ((conc (exp (* t \beta1))))
 674      conc)
 675 |#
 676   )
 677
 678 ;;See
 679 (url-get "www.pfim.biostat.fr")
 680
 681
 682 ;;; Thinking of generics...
 683 (information-matrix model parameters)
 684 (information-matrix variance-matrix)
 685 (information-matrix model data)
 686 (information-matrix list-of-individual-IMs)
 687
 688
 689 (defun IM (loglikelihood parameters times)
 690   "Does double work.  Sum up the resulting IMs to form a full IM."
 691   (let ((IM (make-matrix (length parameters)
 692                          (length parameters)
 693                          :initial-value 0.0d0)))
 694     (dolist (parameterI parameters)
 695       (dolist (parameterJ parameters)
 696         (setf (aref IM I J)
 697               (differentiate (differentiate loglikelihood parameterI) parameterJ))))))
 698 #+END_SRC
 699
 700 *** difference between empirical, fisherian, and ...? information.
 701 *** TODO [#C] Example of Integration with CL-GENOMIC
 702     - State "TODO"       from ""           [2010-10-12 Tue 14:03]
 703
 704     CL-GENOMIC is a very interesting data-structure strategy for
 705     manipulating sequence data.
 706
 707 #+name: CL-GENOMIC
 708 #+begin_src lisp
 709     (in-package :cl-user)
 710     (asdf:oos 'asdf:compile-op :ironclad)
 711     (asdf:oos 'asdf:load-op :cl-genomic)
 712
 713     (in-package :bio-sequence)
 714     (make-dna "agccg") ;; fine
 715     (make-aa "agccg")  ;; fine
 716     (make-aa "agc9zz") ;; error expected
 717 #+end_src
 718
 719 ** TODO [#B] Documentation and Examples [0/3]
 720    - State "TODO"       from ""           [2010-10-14 Thu 00:12]
 721
 722    I've started putting examples of use in function documentation.  If
 723    you are a lisp'er, you'll find this pendantic and insulting.  Many
 724    of the uses are trivial.  However, this has been tested out on a
 725    number of research statisticians (the primary user audience) and
 726    found useful.
 727
 728    Still need to write the
 729
 730 #+BEGIN_SRC lisp
 731   (evaluate-documentation-example 'function-name)
 732 #+END_SRC
 733
 734    function, which would print out the example and run it live.
 735    Hopefully with the same results.  Need to setup the infrastructure,
 736    but basically, we'd like something like:
 737
 738 #+name: Example-InLineDoc
 739 #+begin_src lisp
 740   (cls-example-progn
 741       (example-code-for-function-1)
 742       (example-code-for-function-...)
 743       (example-code-for-function-n))
 744 #+end_src
 745
 746    and have this within the doc-string.  Then the doc-string would be
 747    parsed for the appropriate code and we'd get the results, evaluated
 748    in a special name space derived from the object (function, class)
 749    name, possibly with the corresponding functions and environment
 750    set up that would be required.  OR, it could just work in cl-user
 751    (which is the default starting location.
 752
 753    Here are some possible common lisp systems that could be
 754    evaluated:
 755
 756 *** TODO [#B] Docudown
 757     - State "TODO"       from ""           [2010-11-05 Fri 15:34]
 758
 759 *** TODO [#A] CLDOC
 760     - State "TODO"       from ""           [2010-11-05 Fri 15:34]
 761
 762 *** TODO [#B] CLPDF, and literate data analysis
 763     - State "TODO"       from ""           [2010-11-05 Fri 15:34]
 764
 765 * Proposals
 766   Place proposals for features, work, etc here...
 767 ** <2011-12-29 Thu> new stuff
 768    First new proposal is to track proposals.
 769
 770 * Rejoinder
 771
 772   This project is dedicated to all the lisp hackers out there who
 773   provided the basic infrastructure to get so far so fast with minimal
 774   effort on my part.
 775
 776   And to all the people trying to help to get this off the ground.