TODO.org

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