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