; loading system definition from /usr/local/lib/sbcl/systems/sb-bsd-sockets.asd
; into #<PACKAGE "ASDF3905">
; registering #<SYSTEM SB-BSD-SOCKETS {40490F81}> as SB-BSD-SOCKETS
; registering #<SYSTEM SB-BSD-SOCKETS-TESTS {40857059}> as SB-BSD-SOCKETS-TESTS
; loading system definition from /usr/local/lib/sbcl/systems/sb-posix.asd into
; #<PACKAGE "ASDF4042">
; registering #<SYSTEM SB-POSIX {1073BA29}> as SB-POSIX
; registering #<SYSTEM SB-POSIX-TESTS {108B31A9}> as SB-POSIX-TESTS
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;CL-GRAPH.ASD.NEWEST into #<PACKAGE "ASDF4272">
; registering #<SYSTEM CL-GRAPH {1035E2E9}> as CL-GRAPH
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;CL-MATHSTATS.ASD.NEWEST into
; #<PACKAGE "ASDF4274">
; registering #<SYSTEM CL-MATHSTATS {1052B6F1}> as CL-MATHSTATS
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;CL-CONTAINERS.ASD.NEWEST into
; #<PACKAGE "ASDF4276">
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;ASDF-SYSTEM-CONNECTIONS.ASD.NEWEST into
; #<PACKAGE "ASDF4277">
; registering #<SYSTEM ASDF-SYSTEM-CONNECTIONS {106FC8F1}> as
; ASDF-SYSTEM-CONNECTIONS
; registering #<SYSTEM CL-CONTAINERS {108EEAF9}> as CL-CONTAINERS
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;METATILITIES-BASE.ASD.NEWEST into
; #<PACKAGE "ASDF4301">
; registering #<SYSTEM METATILITIES-BASE {10A98241}> as METATILITIES-BASE
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;MOPTILITIES.ASD.NEWEST into #<PACKAGE "ASDF4303">
; registering #<SYSTEM MOPTILITIES {10C3DA51}> as MOPTILITIES
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;METABANG-BIND.ASD.NEWEST into
; #<PACKAGE "ASDF4305">
; registering #<SYSTEM METABANG-BIND {40296EC1}> as METABANG-BIND
; registering #<SYSTEM-CONNECTION BIND-AND-METATILITIES {40432269}> as
; BIND-AND-METATILITIES
; loading system definition from
; USER-HOME:DARCS;ASDF-SYSTEMS;METATILITIES.ASD.NEWEST into
; #<PACKAGE "ASDF4316">
; registering #<SYSTEM METABANG-GENERIC-LISP {40706581}> as
; METABANG-GENERIC-LISP
; in: LAMBDA NIL
;     (ASDF::RESOLVE-SYMLINKS *LOAD-TRUENAME*)
; ==>
;   *LOAD-TRUENAME*
; 
; note: deleting unreachable code

;     (OR (ASDF::PATHNAME-SANS-NAME+TYPE (ASDF::RESOLVE-SYMLINKS *LOAD-TRUENAME*))
;       *DEFAULT-PATHNAME-DEFAULTS*)
; --> LET IF OR 
; ==>
;   *DEFAULT-PATHNAME-DEFAULTS*
; 
; note: deleting unreachable code
; 
; compilation unit finished
;   printed 2 notes
; registering #<SYSTEM METATILITIES {4088F0A9}> as METATILITIES
;     (ASDF::RESOLVE-SYMLINKS *LOAD-TRUENAME*)
; ==>
;   *LOAD-TRUENAME*
; 
; note: deleting unreachable code

;     (OR (ASDF::PATHNAME-SANS-NAME+TYPE (ASDF::RESOLVE-SYMLINKS *LOAD-TRUENAME*))
;       *DEFAULT-PATHNAME-DEFAULTS*)
; --> LET IF OR 
; ==>
;   *DEFAULT-PATHNAME-DEFAULTS*
; 
; note: deleting unreachable code
; 
; compilation unit finished
;   printed 2 notes
STYLE-WARNING: implicitly creating new generic function SUBCLASSP
STYLE-WARNING: implicitly creating new generic function MOPU-METHOD-SPECIALIZERS
STYLE-WARNING: implicitly creating new generic function MOPU-METHOD-QUALIFIERS
STYLE-WARNING:
   implicitly creating new generic function MOPU-GENERIC-FUNCTION-METHODS
STYLE-WARNING:
   implicitly creating new generic function MOPU-SPECIALIZER-DIRECT-GENERIC-FUNCTIONS
STYLE-WARNING:
   implicitly creating new generic function MOPU-GENERIC-FUNCTION-NAME
STYLE-WARNING: implicitly creating new generic function MOPU-EQL-SPECIALIZER-P
STYLE-WARNING: implicitly creating new generic function RESET
STYLE-WARNING: implicitly creating new generic function MACINTOSH-PATH->UNIX
STYLE-WARNING: implicitly creating new generic function IS-INTERFACE-AVAILABLE-P
STYLE-WARNING: implicitly creating new generic function QUIT-LISP*
STYLE-WARNING: implicitly creating new generic function INTERFACE-BEEP*
STYLE-WARNING: implicitly creating new generic function INTERFACE-BEEP
STYLE-WARNING: redefining QUIT-LISP* in DEFGENERIC
STYLE-WARNING: implicitly creating new generic function GUI-ERROR*
STYLE-WARNING: implicitly creating new generic function GUI-WARN*
STYLE-WARNING: implicitly creating new generic function MAKE-COLOR*
STYLE-WARNING: implicitly creating new generic function MAKE-GRAY*
STYLE-WARNING: implicitly creating new generic function MAKE-GRAY
STYLE-WARNING: implicitly creating new generic function MAKE-SCALED-COLOR*
STYLE-WARNING: implicitly creating new generic function MAKE-SCALED-COLOR
STYLE-WARNING: implicitly creating new generic function CHOOSE-FILE-QUESTION*
STYLE-WARNING:
   implicitly creating new generic function CHOOSE-NEW-FILE-QUESTION*
STYLE-WARNING:
   implicitly creating new generic function CHOOSE-DIRECTORY-QUESTION*
STYLE-WARNING: implicitly creating new generic function CHOOSE-ITEM-QUESTION*
STYLE-WARNING: implicitly creating new generic function CHOOSE-ITEM-FROM-PUP*
STYLE-WARNING: implicitly creating new generic function MAKE-UI-POINT*
STYLE-WARNING: implicitly creating new generic function PROCESS-PARAMETERS*
STYLE-WARNING: implicitly creating new generic function PROCESS-PARAMETERS
STYLE-WARNING: implicitly creating new generic function PUT-ITEM-ON-CLIPBOARD*
STYLE-WARNING: implicitly creating new generic function PUT-ITEM-ON-CLIPBOARD
STYLE-WARNING: implicitly creating new generic function INSPECT-THING*
STYLE-WARNING: implicitly creating new generic function INSPECT-THING
STYLE-WARNING: implicitly creating new generic function SOUND-NOTE*
STYLE-WARNING: implicitly creating new generic function SOUND-NOTE
STYLE-WARNING: implicitly creating new generic function STOP-NOTES*
STYLE-WARNING: implicitly creating new generic function SELECT-INSTRUMENT*
STYLE-WARNING: implicitly creating new generic function SELECT-INSTRUMENT
STYLE-WARNING: implicitly creating new generic function PROMPT-FOR*
STYLE-WARNING: implicitly creating new generic function PROMPT-FOR
STYLE-WARNING: implicitly creating new generic function SHELL-COMMAND*
STYLE-WARNING: implicitly creating new generic function SHELL-COMMAND
STYLE-WARNING: implicitly creating new generic function DEFCLASS*-SUPERCLASSES
STYLE-WARNING:
   implicitly creating new generic function (SETF DEFCLASS*-SUPERCLASSES)
; compiling file "/Users/gwking/darcs/cl-containers/dev/package.lisp" (written 18 NOV 2005 08:16:42 AM):
; compiling (IN-PACKAGE COMMON-LISP-USER)
; compiling (DEFPACKAGE "METABANG.CL-CONTAINERS" ...)

; /Users/gwking/darcs/cl-containers/dev/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/darcs/cl-containers/dev/container-api.lisp" (written 21 OCT 2005 03:54:51 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFGENERIC SAMPLE-ELEMENTS ...)
; compiling (DEFGENERIC SAMPLE-KEY ...)
; compiling (DEFGENERIC SAMPLE-UNIQUE-ELEMENTS ...)
; compiling (DEFGENERIC SAMPLE-ELEMENT ...)
; compiling (DEFGENERIC SAMPLE-ITEM ...)
; compiling (DEFGENERIC BEST-ITEM ...)
; compiling (DEFGENERIC ARGMAX ...)
; compiling (DEFGENERIC ARGMIN ...)
; compiling (DEFGENERIC MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFGENERIC NODE-EMPTY-P ...)
; compiling (DEFGENERIC SIZE ...)
; compiling (DEFGENERIC EMPTY! ...)
; compiling (DEFGENERIC SOME-ITEM-P ...)
; compiling (DEFGENERIC EVERY-ITEM-P ...)
; compiling (DEFGENERIC MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFGENERIC NTH-ELEMENT ...)
; compiling (DEFGENERIC NTH-ITEM ...)
; compiling (DEFGENERIC TOTAL-SIZE ...)
; compiling (DEFGENERIC ITEM-AT ...)
; compiling (DEFGENERIC ITEM-AT! ...)
; compiling (DEFGENERIC FIND-ITEM ...)
; compiling (DEFGENERIC FIND-NODE ...)
; compiling (DEFGENERIC FIND-ELEMENT ...)
; compiling (DEFGENERIC SEARCH-FOR-ITEM ...)
; compiling (DEFGENERIC SEARCH-FOR-MATCH ...)
; compiling (DEFGENERIC ITERATE-NODES ...)
; compiling (DEFGENERIC PRINT-CONTAINER ...)
; compiling (DEFGENERIC COLLECT-NODES ...)
; compiling (DEFGENERIC COLLECT-ELEMENTS ...)
; compiling (DEFGENERIC COLLECT-KEY-VALUE ...)
; compiling (DEFGENERIC COLLECT-KEYS ...)
; compiling (DEFGENERIC ITERATE-KEY-VALUE ...)
; compiling (DEFGENERIC ITERATE-VALUE-KEY ...)
; compiling (DEFGENERIC FIRST-ITEM ...)
; compiling (DEFGENERIC LAST-ITEM ...)
; compiling (DEFGENERIC DELETE-FIRST ...)
; compiling (DEFGENERIC DELETE-LAST ...)
; compiling (DEFGENERIC INSERT-ITEM ...)
; compiling (DEFGENERIC APPEND-ITEM ...)
; compiling (DEFGENERIC INSERT-NEW-ITEM ...)
; compiling (DEFGENERIC APPEND-NEW-ITEM ...)
; compiling (DEFGENERIC INSERT-SEQUENCE ...)
; compiling (DEFGENERIC INSERT-LIST ...)
; compiling (DEFGENERIC DELETE-LIST ...)
; compiling (DEFGENERIC REVERSE-FIND ...)
; compiling (DEFGENERIC ENQUEUE ...)
; compiling (DEFGENERIC DEQUEUE ...)
; compiling (DEFGENERIC POP-ITEM ...)
; compiling (DEFGENERIC CHILDREN ...)
; compiling (DEFGENERIC ENSURE-SORTED ...)
; compiling (DEFGENERIC FORCE-SORT ...)
; compiling (DEFGENERIC REMOVE-ITEMS-IF ...)
; compiling (DEFGENERIC CONTAINER->ARRAY ...)
; compiling (DEFGENERIC ELEMENT-POSITION ...)
; compiling (DEFGENERIC DELETE-ITEM ...)
; compiling (DEFGENERIC DELETE-ITEM-IF ...)

; /Users/gwking/darcs/cl-containers/dev/container-api.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/cl-containers/dev/containers.lisp" (written 21 OCT 2005 03:54:51 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFPARAMETER +EMPTY-INITIAL-ELEMENT+ ...)
; compiling (DEFCLASS* ABSTRACT-CONTAINER ...)
; compiling (DEFCLASS* CONCRETE-CONTAINER ...)
; compiling (DEFCLASS* CONTAINER-NODE-MIXIN ...)
; compiling (DEFCLASS* LIST-CONTAINER ...)
; compiling (DEFCLASS* PARENT-NODE-MIXIN ...)
; compiling (DEFCLASS* TWO-CHILD-NODE ...)
; compiling (DEFCLASS* KEYED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* TYPED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* BOUNDED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* INDEXED-CONTAINER-MIXIN ...)
; compiling (DEFMETHOD (SETF ITEM-AT) ...)
; compiling (DEFCLASS* INITIAL-ELEMENT-MIXIN ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFUN RETURN-EMPTY-INITIAL-ELEMENT ...)
; compiling (DEFMETHOD MAKE-INITIAL-ELEMENT ...)
; compiling (DEFCLASS* BASIC-INITIAL-CONTENTS-MIXIN ...)
; compiling (DEFCLASS* INITIAL-CONTENTS-MIXIN ...)
; compiling (DEFGENERIC INSERT-INITIAL-CONTENTS-P ...)
; compiling (DEFCLASS* INITIAL-CONTENTS-KEY-VALUE-MIXIN ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS* TEST-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* CONTAINER-USES-NODES-MIXIN ...)
; compiling (DEFCLASS* FINDABLE-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* SEARCHABLE-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* ITERATABLE-CONTAINER-MIXIN ...)
; compiling (DEFGENERIC ITERATABLE-P ...)
; compiling (DEFMETHOD ITERATE-CONTAINER ...)
; compiling (DEFMETHOD COLLECT-ITEMS ...)
; compiling (DEFCLASS* I-KNOW-MY-NODE-MIXIN ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFCLASS* NON-ASSOCIATIVE-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* UNORDERED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* ORDERED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* SORTED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* CLASSIFIED-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* USES-CONTENTS-MIXIN ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFCLASS* CONTENTS-AS-SEQUENCE-MIXIN ...)
; compiling (DEFCLASS* CONTENTS-AS-ARRAY-MIXIN ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD TOTAL-SIZE ...)
; compiling (DEFMETHOD INSERT-INITIAL-CONTENTS-P ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFCLASS* CONTENTS-AS-LIST-MIXIN ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFCLASS* CONTENTS-AS-HASHTABLE-MIXIN ...)
; compiling (DEFCLASS* STABLE-ASSOCIATIVE-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS* ASSOCIATIVE-ARRAY ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)

; /Users/gwking/darcs/cl-containers/dev/containers.fasl written
; compilation finished in 0:00:11
STYLE-WARNING: implicitly creating new generic function (SETF ITEM-AT)
STYLE-WARNING: implicitly creating new generic function MAKE-INITIAL-ELEMENT
STYLE-WARNING: implicitly creating new generic function ITERATE-CONTAINER
STYLE-WARNING: implicitly creating new generic function COLLECT-ITEMS
STYLE-WARNING: implicitly creating new generic function MAKE-NODE-FOR-CONTAINER
STYLE-WARNING: implicitly creating new generic function COLLECT-ELEMENTS
STYLE-WARNING: implicitly creating new generic function ITERATE-NODES
STYLE-WARNING: implicitly creating new generic function SIZE
STYLE-WARNING: implicitly creating new generic function TOTAL-SIZE
STYLE-WARNING:
   implicitly creating new generic function MAKE-CONTAINER-FOR-CONTENTS
; compiling file "/Users/gwking/darcs/cl-containers/dev/basic-operations.lisp" (written 28 OCT 2005 12:18:11 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCONDITION CONTAINER-ERROR ...)
; compiling (DEFCONDITION INDEX-OUT-OF-RANGE-ERROR ...)
; compiling (DEFGENERIC MAKE-CONTAINER ...)
; compiling (DEFUN FIND-MATCHING-CONTAINER-CLASS ...)
; compiling (DEFGENERIC EMPTY-P ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD FIND-ELEMENT ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ELEMENT ...)
; compiling (DEFMETHOD PRINT-CONTAINER ...)
; compiling (DEPRECATED "Use collect-elements instead." ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD COLLECT-NODES ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFUN COLLECTOR-INTERNAL ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-ELEMENT ...)
; compiling (DEFMETHOD SEARCH-FOR-NODE ...)
; compiling (DEFUN %SEARCH-IN-CONTAINER ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCH ...)
; compiling (DEFUN %SEARCH-FOR-MATCH ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCHING-NODE ...)
; compiling (DEFMETHOD SEARCH-FOR-NODE ...)
; compiling (DEFMETHOD SEARCH-FOR-NODE ...)
; compiling (DEFMETHOD SEARCH-FOR-NODE* ...)
; compiling (DEFMETHOD SEARCH-FOR-NODE* ...)
; compiling (DEFMETHOD BEST-ITEM ...)
; compiling (DEFMETHOD BEST-ITEM ...)
; compiling (DEFMETHOD BEST-NODE ...)
; compiling (DEFMETHOD BEST-ELEMENT ...)
; compiling (DEFUN %BEST-HELPER ...)
; compiling (DEFMETHOD ARGMAX ...)
; file: /Users/gwking/darcs/cl-containers/dev/basic-operations.lisp
; in: DEFMETHOD ARGMAX (T T)
;     (DEFMETHOD METABANG.UTILITIES:ARGMAX
;              ((METABANG.CL-CONTAINERS::ITEMS T) FUNCTION &REST
;               METABANG.CL-CONTAINERS::ARGS &KEY METABANG.CL-CONTAINERS::KEY
;               METABANG.CL-CONTAINERS:FILTER)
;              (DECLARE
;               (IGNORE METABANG.CL-CONTAINERS::TEST
;                       METABANG.CL-CONTAINERS::KEY
;                       METABANG.CL-CONTAINERS:FILTER))
;              (APPLY #'METABANG.UTILITIES:BEST-ITEM
;                     METABANG.CL-CONTAINERS::ITEMS
;                     FUNCTION
;                     :TEST
;                     #'>
;                     METABANG.CL-CONTAINERS::ARGS))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET 
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET 
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS 
; ==>
;   (LET* ((SB-PCL::.ARGS-TAIL. SB-PCL::.REST-ARG.)
;          (METABANG.CL-CONTAINERS::ARGS SB-PCL::.ARGS-TAIL.)
;          (METABANG.CL-CONTAINERS::KEY
;           (CAR (SB-PCL::GET-KEY-ARG-TAIL :KEY SB-PCL::.ARGS-TAIL.)))
;          (METABANG.CL-CONTAINERS:FILTER
;           (CAR (SB-PCL::GET-KEY-ARG-TAIL :FILTER SB-PCL::.ARGS-TAIL.)))
;          (SB-PCL::.DUMMY0.))
;     (DECLARE (IGNORABLE SB-PCL::.ARGS-TAIL. SB-PCL::.DUMMY0.))
;     (DECLARE
;      (IGNORE METABANG.CL-CONTAINERS:FILTER
;              METABANG.CL-CONTAINERS::KEY
;              METABANG.CL-CONTAINERS::TEST))
;     (BLOCK METABANG.UTILITIES:ARGMAX
;       (APPLY #'METABANG.UTILITIES:BEST-ITEM
;              METABANG.CL-CONTAINERS::ITEMS
;              FUNCTION
;              :TEST
;              #'>
;              METABANG.CL-CONTAINERS::ARGS)))
; 
; caught STYLE-WARNING:
;   declaring unknown variable TEST to be ignored

; compiling (DEFMETHOD ARGMIN ...)
; file: /Users/gwking/darcs/cl-containers/dev/basic-operations.lisp
; in: DEFMETHOD ARGMIN (T T)
;     (DEFMETHOD METABANG.UTILITIES:ARGMIN
;              ((METABANG.CL-CONTAINERS::ITEMS T) FUNCTION &REST
;               METABANG.CL-CONTAINERS::ARGS &KEY METABANG.CL-CONTAINERS::KEY
;               METABANG.CL-CONTAINERS:FILTER)
;              (DECLARE
;               (IGNORE METABANG.CL-CONTAINERS::TEST
;                       METABANG.CL-CONTAINERS::KEY
;                       METABANG.CL-CONTAINERS:FILTER))
;              (APPLY #'METABANG.UTILITIES:BEST-ITEM
;                     METABANG.CL-CONTAINERS::ITEMS
;                     FUNCTION
;                     :TEST
;                     #'<
;                     METABANG.CL-CONTAINERS::ARGS))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET 
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET 
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS 
; ==>
;   (LET* ((SB-PCL::.ARGS-TAIL. SB-PCL::.REST-ARG.)
;          (METABANG.CL-CONTAINERS::ARGS SB-PCL::.ARGS-TAIL.)
;          (METABANG.CL-CONTAINERS::KEY
;           (CAR (SB-PCL::GET-KEY-ARG-TAIL :KEY SB-PCL::.ARGS-TAIL.)))
;          (METABANG.CL-CONTAINERS:FILTER
;           (CAR (SB-PCL::GET-KEY-ARG-TAIL :FILTER SB-PCL::.ARGS-TAIL.)))
;          (SB-PCL::.DUMMY0.))
;     (DECLARE (IGNORABLE SB-PCL::.ARGS-TAIL. SB-PCL::.DUMMY0.))
;     (DECLARE
;      (IGNORE METABANG.CL-CONTAINERS:FILTER
;              METABANG.CL-CONTAINERS::KEY
;              METABANG.CL-CONTAINERS::TEST))
;     (BLOCK METABANG.UTILITIES:ARGMIN
;       (APPLY #'METABANG.UTILITIES:BEST-ITEM
;              METABANG.CL-CONTAINERS::ITEMS
;              FUNCTION
;              :TEST
;              #'<
;              METABANG.CL-CONTAINERS::ARGS)))
; 
; caught STYLE-WARNING:
;   declaring unknown variable TEST to be ignored

; compiling (DEFMETHOD REDUCE-CONTAINER ...)
; compiling (DEFMETHOD REDUCE-ELEMENTS ...)
; compiling (DEFMETHOD REDUCE-NODES ...)
; compiling (DEFUN REDUCE-INTERNAL ...)
; compiling (DEFMETHOD DELETE-ITEM-IF ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFCLASS* KEY-VALUE-ITERATABLE-CONTAINER-MIXIN ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-LIST ...)
; compiling (DEFMETHOD INSERT-LIST ...)
; compiling (DEFMETHOD INSERT-SEQUENCE ...)
; compiling (DEFMETHOD INSERT-SEQUENCE ...)
; compiling (DEFMETHOD INSERT-SEQUENCE ...)
; compiling (DEFMETHOD INSERT-NEW-ITEM ...)
; compiling (DEFGENERIC SUCCESSOR ...)
; compiling (DEFGENERIC PREDECESSOR ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEPRECATED "Use collect-elements instead." ...)
; compiling (DEFMETHOD SORT-ELEMENTS ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD SOME-ITEM-P ...)
; compiling (DEFMETHOD EVERY-ITEM-P ...)
; compiling (DEFMETHOD SOME-ELEMENT-P ...)
; compiling (DEFMETHOD EVERY-ELEMENT-P ...)
; compiling (DEFUN %EVERY-THING-P ...)
; compiling (DEFUN %SOME-THING-P ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD APPEND-ITEM ...)
; compiling (DEFMETHOD APPEND-NEW-ITEM ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATE-KEYS ...)
; compiling (DEFMETHOD COLLECT-KEY-VALUE ...)
; compiling (DEFUN %COLLECT-KEY-VALUE ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD REVERSE-FIND ...)
; compiling (DEFMETHOD FIND-VALUE ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD ADD-DEFAULT-ITEM ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD ITERATE-KEYS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS-STABLY ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)
; compiling (DEFMETHOD COLLECT-KEYS ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE-STABLY ...)
; compiling (DEFMETHOD COLLECT-KEY-VALUE-STABLY ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS-STABLY ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFUN TUPLE-INDEX ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD CONTAINER-DIMENSION ...)
; compiling (DEFMETHOD DIMENSIONS ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFUN COLLECT-USING ...)
; compiling (DEFUN COUNT-USING ...)
; compiling (DEFMETHOD CONTAINER-DIFFERENCE ...)
; compiling (DEFUN ASSOCIATIVE-CONTAINER-P ...)
; compiling (DEFMETHOD ADD-INITIAL-CONTENTS ...)
; compiling (DEFMETHOD ADD-INITIAL-CONTENTS ...)
; compiling (DEFUN ADD-INITIAL-CONTENTS-INTERNAL ...)
; compiling (DEFMETHOD ADD-INITIAL-CONTENTS ...)
; compiling (DEFMETHOD ELEMENT-POSITION ...)
; compiling (DEFMETHOD ELEMENT-POSITION ...)
; compiling (DEFMETHOD SAMEP ...)
; compiling (DEFMETHOD SAMEP ...)
; compiling (DEFMETHOD SAMEP ...)
; compiling (DEFMETHOD SAMEP ...)

; /Users/gwking/darcs/cl-containers/dev/basic-operations.fasl written
; compilation finished in 0:18:24
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10003249}> on
   #<CL-SOURCE-FILE "basic-operations" {10003259}>.
STYLE-WARNING: implicitly creating new generic function ITERATE-ELEMENTS
STYLE-WARNING: implicitly creating new generic function FIND-ELEMENT
STYLE-WARNING: implicitly creating new generic function DELETE-ITEM
STYLE-WARNING: implicitly creating new generic function DELETE-ELEMENT
STYLE-WARNING: implicitly creating new generic function PRINT-CONTAINER
STYLE-WARNING: implicitly creating new generic function CONTAINER->LIST
STYLE-WARNING: implicitly creating new generic function NTH-ELEMENT
STYLE-WARNING: implicitly creating new generic function COLLECT-NODES
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-ITEM
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-ELEMENT
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-NODE
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-MATCH
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-MATCHING-NODE
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-NODE*
STYLE-WARNING: implicitly creating new generic function BEST-ITEM
STYLE-WARNING: implicitly creating new generic function BEST-NODE
STYLE-WARNING: implicitly creating new generic function BEST-ELEMENT
STYLE-WARNING: implicitly creating new generic function ARGMAX
STYLE-WARNING: implicitly creating new generic function ARGMIN
STYLE-WARNING: implicitly creating new generic function REDUCE-CONTAINER
STYLE-WARNING: implicitly creating new generic function REDUCE-ELEMENTS
STYLE-WARNING: implicitly creating new generic function REDUCE-NODES
STYLE-WARNING: implicitly creating new generic function DELETE-ITEM-IF
STYLE-WARNING: implicitly creating new generic function FIRST-ITEM
STYLE-WARNING: implicitly creating new generic function DELETE-LIST
STYLE-WARNING: implicitly creating new generic function INSERT-LIST
STYLE-WARNING: implicitly creating new generic function INSERT-SEQUENCE
STYLE-WARNING: implicitly creating new generic function INSERT-NEW-ITEM
STYLE-WARNING: implicitly creating new generic function SORT-ELEMENTS
STYLE-WARNING: implicitly creating new generic function EMPTY!
STYLE-WARNING: implicitly creating new generic function FIND-ITEM
STYLE-WARNING: implicitly creating new generic function SOME-ITEM-P
STYLE-WARNING: implicitly creating new generic function EVERY-ITEM-P
STYLE-WARNING: implicitly creating new generic function SOME-ELEMENT-P
STYLE-WARNING: implicitly creating new generic function EVERY-ELEMENT-P
STYLE-WARNING: implicitly creating new generic function INSERT-ITEM
STYLE-WARNING: implicitly creating new generic function APPEND-ITEM
STYLE-WARNING: implicitly creating new generic function APPEND-NEW-ITEM
STYLE-WARNING: implicitly creating new generic function ITERATE-KEYS
STYLE-WARNING: implicitly creating new generic function COLLECT-KEY-VALUE
STYLE-WARNING: implicitly creating new generic function REVERSE-FIND
STYLE-WARNING: implicitly creating new generic function FIND-VALUE
STYLE-WARNING: implicitly creating new generic function ITEM-AT!
STYLE-WARNING: implicitly creating new generic function ADD-DEFAULT-ITEM
STYLE-WARNING: implicitly creating new generic function ITEM-AT
STYLE-WARNING: implicitly creating new generic function ITERATE-ELEMENTS-STABLY
STYLE-WARNING: implicitly creating new generic function ITERATE-KEY-VALUE
STYLE-WARNING: implicitly creating new generic function COLLECT-KEYS
STYLE-WARNING: implicitly creating new generic function ITERATE-KEY-VALUE-STABLY
STYLE-WARNING: implicitly creating new generic function COLLECT-KEY-VALUE-STABLY
STYLE-WARNING: implicitly creating new generic function COLLECT-ELEMENTS-STABLY
STYLE-WARNING: implicitly creating new generic function CONTAINER-DIMENSION
STYLE-WARNING: implicitly creating new generic function DIMENSIONS
STYLE-WARNING: implicitly creating new generic function CONTAINER-DIFFERENCE
STYLE-WARNING: implicitly creating new generic function ADD-INITIAL-CONTENTS
STYLE-WARNING: implicitly creating new generic function ELEMENT-POSITION
; compiling file "/Users/gwking/darcs/cl-containers/dev/queues.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* ABSTRACT-QUEUE ...)
; compiling (DEFINE-CONDITION EKSL-QUEUE-EMPTY ...)
; compiling (DEFMETHOD ENQUEUE ...)
; compiling (DEFMETHOD DEQUEUE ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD ERROR-IF-QUEUE-EMPTY ...)
; compiling (DEFCLASS* PRIORITY-QUEUE-ON-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD FIND-NODE ...)
; compiling (DEFMETHOD FIND-ELEMENT ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-NODE ...)
; compiling (DEFMETHOD DELETE-ELEMENT ...)
; compiling (DEFMETHOD DELETE-ITEM-IF ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFCLASS* BASIC-QUEUE ...)
; compiling (DEFUN FRONT-OF-QUEUE ...)
; compiling (DEFUN FRONT-OF-QUEUE! ...)
; compiling (DEFSETF FRONT-OF-QUEUE ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN TAIL-OF-QUEUE ...)
; compiling (DEFUN TAIL-OF-QUEUE! ...)
; compiling (DEFSETF TAIL-OF-QUEUE ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD DELETE-ITEM ...)

; /Users/gwking/darcs/cl-containers/dev/queues.fasl written
; compilation finished in 0:00:25
; compiling file "/Users/gwking/darcs/cl-containers/dev/stacks.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* ABSTRACT-STACK ...)
; compiling (DEFMETHOD (SETF FIRST-ITEM) ...)
; compiling (DEFMETHOD PUSH-ITEM ...)
; compiling (DEFCLASS* STACK-CONTAINER ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD POP-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)

; /Users/gwking/darcs/cl-containers/dev/stacks.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/darcs/cl-containers/dev/trees.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* ABSTRACT-TREE-CONTAINER ...)
; compiling (DEFCLASS* ROOTED-TREE-CONTAINER ...)
; compiling (DEFCLASS* MANY-CHILD-NODE ...)
; compiling (DEFMETHOD ITERATE-CHILDREN ...)
; compiling (DEFMETHOD HAS-CHILDREN-P ...)
; compiling (DEFMETHOD FIND-CHILD-NODE ...)
; compiling (DEFCLASS* MANY-ORDERED-CHILD-NODE ...)
; compiling (DEFMETHOD CHILDREN ...)
; compiling (DEFCLASS* MANY-UNORDERED-CHILD-NODE ...)
; compiling (DEFCLASS* BINARY-SEARCH-TREE ...)
; compiling (DEFCLASS* BST-NODE ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD NODE-EMPTY-P ...)
; compiling (DEFMETHOD NODE-EMPTY-P ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD FIND-NODE ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFMETHOD SUCCESSOR ...)
; compiling (DEFMETHOD PREDECESSOR ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-NODE ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM-IF ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD INORDER-WALK ...)
; compiling (DEFMETHOD PREORDER-WALK ...)
; compiling (DEFMETHOD POSTORDER-WALK ...)
; compiling (DEFMETHOD INORDER-WALK-NODES ...)
; compiling (DEFMETHOD PREORDER-WALK-NODES ...)
; compiling (DEFMETHOD POSTORDER-WALK-NODES ...)
; compiling (DEFMETHOD WALK-TREE ...)
; compiling (DEFMETHOD WALK-TREE ...)
; compiling (DEFMETHOD WALK-TREE-NODES ...)
; compiling (DEFMETHOD WALK-TREE-NODES ...)
; compiling (DEFCONSTANT +RBT-COLOR-BLACK+ ...)
; compiling (DEFCONSTANT +RBT-COLOR-RED+ ...)
; compiling (DEFVAR *RBT-EMPTY-NODE* ...)
; compiling (DEFCLASS* RED-BLACK-TREE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS* RED-BLACK-NODE ...)
; compiling (DEFMETHOD NODE-EMPTY-P ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (SETF *RBT-EMPTY-NODE* ...)
; compiling (DEFMETHOD ROTATE-LEFT ...)
; compiling (DEFMETHOD ROTATE-RIGHT ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD RB-DELETE-FIXUP ...)
; compiling (DEFMETHOD WALK-TREE-NODES ...)
; compiling (DEFMETHOD WALK-TREE ...)
; compiling (DEFMETHOD HEIGHT ...)
; compiling (DEFMETHOD HEIGHT ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD UPDATE-ELEMENT ...)
; compiling (DEFGENERIC BST-NODE-IS-LEFT-CHILD ...)
; compiling (DEFGENERIC BST-NODE-IS-RIGHT-CHILD ...)
; compiling (DEFGENERIC BST-NODE-SET-RIGHT-CHILD ...)
; compiling (DEFGENERIC BST-NODE-SET-LEFT-CHILD ...)
; compiling (DEFGENERIC BST-NODE-REPLACE-CHILD ...)
; compiling (DEFCLASS* SPLAY-TREE ...)
; compiling (DEFGENERIC SPLAY-TREE-ROTATE ...)
; compiling (DEFGENERIC SPLAY-TREE-SPLAY ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD UPDATE-ELEMENT ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFGENERIC RIGHT-MOST-CHILD ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM-AT ...)

; /Users/gwking/darcs/cl-containers/dev/trees.fasl written
; compilation finished in 0:00:22
; compiling file "/Users/gwking/darcs/cl-containers/dev/lists.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFMETHOD INSERT-LIST ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD PRINT-CONTAINER ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFCLASS* SORTED-LIST-CONTAINER ...)
; compiling (DEFMETHOD SET-DIRTY-FLAG ...)
; compiling (DEFMETHOD CLEAN-UP ...)
; compiling (DEFMETHOD INSERT-LIST ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD PRINT-CONTAINER ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD ENSURE-SORTED ...)
; compiling (DEFMETHOD FORCE-SORT ...)
; compiling (DEFCLASS* DLIST-CONTAINER-NODE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFCLASS* DLIST-CONTAINER ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM-AFTER ...)
; compiling (DEFMETHOD INSERT-ITEM-AFTER ...)
; compiling (DEFMETHOD INSERT-ITEM-AFTER ...)
; compiling (DEFMETHOD INSERT-ITEM-AFTER ...)
; compiling (DEFMETHOD INSERT-ITEM-BEFORE ...)
; compiling (DEFMETHOD INSERT-ITEM-BEFORE ...)
; compiling (DEFMETHOD INSERT-ITEM-BEFORE ...)
; compiling (DEFMETHOD DELETE-ITEM-AFTER ...)
; compiling (DEFMETHOD DELETE-ITEM-BEFORE ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD REPLACE-ITEM ...)
; compiling (DEFMETHOD REPLACE-ITEM ...)
; compiling (DEFMETHOD SUCCESSOR ...)
; compiling (DEFMETHOD PREDECESSOR ...)
; compiling (DEFCLASS* SORTED-DLIST-CONTAINER ...)
; compiling (DEFMETHOD ITERATE-NODES-ABOUT-NODE ...)
; compiling (DEFMETHOD ITERATE-NODES-ABOUT-NODE ...)
; compiling (DEFMETHOD ITERATE-NODES-ABOUT-NODE ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM-ORDERED-ABOUT-NODE ...)
; compiling (DEFMETHOD INSERT-ITEM-ORDERED-ABOUT-NODE ...)
; compiling (DEFMETHOD INSERT-ITEM-ORDERED-ABOUT-NODE ...)
; compiling (DEFMETHOD INSERT-ITEM-ORDERED ...)
; compiling (DEFMETHOD INSERT-ITEM-ORDERED ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD FORCE-SORT ...)
; compiling (DEFMETHOD ENSURE-SORTED ...)
; compiling (DEFMETHOD LEFT-NODE-FOR-ITEM ...)
; compiling (DEFMETHOD RIGHT-NODE-FOR-ITEM ...)
; compiling (DEFMETHOD LEFT-AND-RIGHT-NODES-FOR-ITEM ...)
; compiling (DEFMETHOD ITERATE-LEFT-NODES ...)
; compiling (DEFMETHOD ITERATE-LEFT-NODES ...)
; compiling (DEFMETHOD ITERATE-LEFT-NODES ...)
; compiling (DEFMETHOD ITERATE-RIGHT-NODES ...)
; compiling (DEFMETHOD ITERATE-RIGHT-NODES ...)
; compiling (DEFMETHOD ITERATE-RIGHT-NODES ...)
; compiling (DEFMETHOD ITERATE-LEFT ...)
; compiling (DEFMETHOD ITERATE-LEFT ...)
; compiling (DEFMETHOD ITERATE-LEFT ...)
; compiling (DEFMETHOD ITERATE-RIGHT ...)
; compiling (DEFMETHOD ITERATE-RIGHT ...)
; compiling (DEFMETHOD ITERATE-RIGHT ...)
; compiling (DEFMETHOD SORT-UPDATE-LEFT ...)
; compiling (DEFMETHOD SORT-UPDATE-RIGHT ...)
; compiling (DEFMETHOD UPDATE-ITEM ...)
; compiling (DEFMETHOD UPDATE-ITEM ...)
; compiling (DEFMETHOD UPDATE-ITEM ...)

; /Users/gwking/darcs/cl-containers/dev/lists.fasl written
; compilation finished in 0:00:27
; compiling file "/Users/gwking/darcs/cl-containers/dev/bags-and-sets.lisp" (written 21 OCT 2005 03:54:51 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCLASS* ABSTRACT-BAG/SET-CONTAINER ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFCLASS* BAG-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCH ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFCLASS* SET-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFCLASS* BAG/SET-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD FIND-VALUE ...)
; compiling (DEFCLASS* KEYED-BAG/SET-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD ITERATE-NODES ...)

; /Users/gwking/darcs/cl-containers/dev/bags-and-sets.fasl written
; compilation finished in 0:00:08
; compiling file "/Users/gwking/darcs/cl-containers/dev/ring-buffers.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* RING-BUFFER ...)
; compiling (DEFUN MAKE-RING-BUFFER ...)
; compiling (DEFMETHOD MAKE-CONTAINER ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD INCREMENT-END ...)
; compiling (DEFMETHOD NEXT-ITEM ...)
; compiling (DEFMETHOD CURRENT-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD ITERATE-NODES ...)

; /Users/gwking/darcs/cl-containers/dev/ring-buffers.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/darcs/cl-containers/dev/miscellaneous.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (EXPORT (QUOTE #))
; compiling (DEFUN MERGE-ELEMENTS ...)
; compiling (DEFUN MERGE-NODES ...)
; compiling (DEFUN %MERGE-HELPER ...)
; compiling (DEFUN ELEMENT-COUNTS ...)
; compiling (DEFUN NODE-COUNTS ...)
; compiling (DEFUN %CONTAINER-COUNTS ...)
; compiling (DEFUN MAP-WINDOW-OVER-ELEMENTS ...)
; compiling (DEFUN MAP-WINDOW-OVER-NODES ...)
; compiling (DEFUN COLLECT-WINDOW-OVER-ELEMENTS ...)
; compiling (DEFUN COLLECT-WINDOW-OVER-NODES ...)
; compiling (DEFUN MAP-WINDOW-OVER-ELEMENTS-HELPER ...)
; compiling (DEFUN MAP-PAIRS ...)
; compiling (DEFUN COLLECT-PAIRS ...)

; /Users/gwking/darcs/cl-containers/dev/miscellaneous.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-containers/dev/associative.lisp" (written 21 OCT 2005 03:54:51 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* ASSOCIATIVE-CONTAINER-MIXIN ...)
; compiling (DEFMETHOD SOME-KEY-VALUE-P ...)
; compiling (DEFMETHOD EVERY-KEY-VALUE-P ...)
; compiling (DEFMETHOD SAMEP ...)
; compiling (DEFMETHOD COLLECT-KEYS ...)
; compiling (DEFMETHOD SEARCH-FOR-KEY ...)
; compiling (DEFMETHOD REMOVE-ITEMS-IF ...)
; compiling (DEFMETHOD REMOVE-ITEMS-IF ...)
; compiling (DEFMETHOD COUNT-ITEMS ...)
; compiling (DEFMETHOD COUNT-ELEMENTS ...)
; compiling (DEFMETHOD COUNT-ELEMENTS ...)
; compiling (DEFMETHOD COUNT-ELEMENTS-IF ...)
; compiling (DEFMETHOD COUNT-ELEMENTS-IF ...)
; compiling (DEFCLASS* ARRAY-CONTAINER-ABSTRACT ...)
; compiling (DEFCLASS* ARRAY-CONTAINER ...)
; compiling (DEFMETHOD PRINT-CONTAINER-SUMMARY ...)
; compiling (DEFUN MAKE-ARRAY-CONTAINER ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFMETHOD MAKE-CONTAINER ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD DIMENSIONS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; file: /Users/gwking/darcs/cl-containers/dev/associative.lisp
; in: DEFMETHOD ITERATE-NODES (ARRAY-CONTAINER T)
;     (DEFMETHOD METABANG.CL-CONTAINERS:ITERATE-NODES
;              ((METABANG.CL-CONTAINERS::CONTAINER
;                METABANG.CL-CONTAINERS:ARRAY-CONTAINER)
;               METABANG.CL-CONTAINERS::FN)
;              (WITH-SLOTS
;               (METABANG.CL-CONTAINERS:CONTENTS METABANG.CL-CONTAINERS:CONTENTS)
;               METABANG.CL-CONTAINERS::CONTAINER
;               (DOTIMES
;                   (METABANG.CL-CONTAINERS::I
;                    (ARRAY-TOTAL-SIZE METABANG.CL-CONTAINERS:CONTENTS))
;                 (FUNCALL METABANG.CL-CONTAINERS::FN
;                          (ROW-MAJOR-AREF METABANG.CL-CONTAINERS:CONTENTS
;                                          METABANG.CL-CONTAINERS::I)))))
; --> PROGN SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION MACROLET 
; --> SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS 
; --> SB-PCL::BIND-FAST-LEXICAL-METHOD-MACROS MACROLET 
; --> SB-PCL::BIND-LEXICAL-METHOD-FUNCTIONS SB-PCL::CALL-NEXT-METHOD-BIND LET 
; --> FLET SB-PCL::WITH-REBOUND-ORIGINAL-ARGS LET SB-PCL::BIND-ARGS LET* 
; --> SB-PCL::PV-BINDING SB-PCL::PV-BINDING1 SB-PCL::PV-ENV LET LET BLOCK LET 
; ==>
;   (SYMBOL-MACROLET ((METABANG.CL-CONTAINERS:CONTENTS
;                      (SLOT-VALUE #:G698 'METABANG.CL-CONTAINERS:CONTENTS))
;                     (METABANG.CL-CONTAINERS:CONTENTS
;                      (SLOT-VALUE #:G698 'METABANG.CL-CONTAINERS:CONTENTS)))
;     (BLOCK NIL
;       (LET ((METABANG.CL-CONTAINERS::I 0) (#:G702 #))
;         (DECLARE (TYPE UNSIGNED-BYTE METABANG.CL-CONTAINERS::I))
;         (TAGBODY
;           (GO #:G704)
;          #:G703
;           (TAGBODY #)
;           (PSETQ METABANG.CL-CONTAINERS::I #)
;          #:G704
;           (UNLESS # #)
;           (RETURN-FROM NIL #)))))
; 
; caught STYLE-WARNING:
;   duplicate definitions in ((CONTENTS (SLOT-VALUE #:G698 'CONTENTS))
;                             (CONTENTS (SLOT-VALUE #:G698 'CONTENTS)))

; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFCLASS* SPARSE-ARRAY-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFMETHOD TOTAL-SIZE ...)
; compiling (DEFUN SPARSE-ARRAY-ROW-MAJOR-INDEX ...)
; compiling (DEFUN SPARSE-ARRAY-VALUE-TO-INDEX ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFCLASS* SIMPLE-ASSOCIATIVE-CONTAINER ...)
; compiling (DEFMETHOD ITEM-AT-1 ...)
; compiling (DEFMETHOD ITEM-AT-1! ...)
; compiling (DEFMETHOD (SETF ITEM-AT-1) ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD DELETE-ITEM-AT ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)
; compiling (DEFCLASS* ASSOCIATIVE-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD DELETE-ITEM-AT ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)
; compiling (DEFUN DESCEND-HT ...)
; compiling (DEFUN FIND-OR-CREATE-HT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD PRINT-CONTAINER ...)
; compiling (DEFMETHOD PRINT-CONTAINER ...)
; compiling (DEFCLASS* BIASSOCIATIVE-CONTAINER-MIXIN ...)
; compiling (DEFCLASS* ALIST-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-CONTAINER ...)
; compiling (DEFMETHOD MAKE-CONTAINER-FOR-CONTENTS ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT-1 ...)
; compiling (DEFMETHOD ITEM-AT-1! ...)
; compiling (DEFUN MAYBE-SET-INITIAL-ELEMENT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; file: /Users/gwking/darcs/cl-containers/dev/associative.lisp
; in: DEFMETHOD ITEM-AT! (ALIST-CONTAINER T)
;     (WITH-SLOTS (METABANG.CL-CONTAINERS:CONTENTS METABANG.CL-CONTAINERS:CONTENTS)
;               METABANG.CL-CONTAINERS::CONTAINER
;               (PUSH METABANG.CL-CONTAINERS::ITEM
;                     METABANG.CL-CONTAINERS:CONTENTS))
; --> LET 
; ==>
;   (SYMBOL-MACROLET ((METABANG.CL-CONTAINERS:CONTENTS
;                      (SLOT-VALUE #:G1839 'METABANG.CL-CONTAINERS:CONTENTS))
;                     (METABANG.CL-CONTAINERS:CONTENTS
;                      (SLOT-VALUE #:G1839 'METABANG.CL-CONTAINERS:CONTENTS)))
;     (PUSH METABANG.CL-CONTAINERS::ITEM METABANG.CL-CONTAINERS:CONTENTS))
; 
; caught STYLE-WARNING:
;   duplicate definitions in ((CONTENTS (SLOT-VALUE #:G1839 'CONTENTS))
;                             (CONTENTS (SLOT-VALUE #:G1839 'CONTENTS)))

; compiling (DEFMETHOD DELETE-ITEM-AT ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATE-KEYS ...)
; compiling (DEFMETHOD REVERSE-FIND ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)
; compiling (DEFMETHOD SORT-KEYS ...)
; compiling (DEFMETHOD SORT-ELEMENTS ...)
; compiling (DEFMETHOD SORT-CONTAINER ...)
; compiling (DEFCLASS* KEYED-ASSOCIATIVE-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFUN IDENTITY-2 ...)
; compiling (DEFMETHOD ITEM-KEY ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD DELETE-ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFGENERIC KEY-EXISTS-P ...)
; compiling (DEFMETHOD KEY-EXISTS-P ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)

; /Users/gwking/darcs/cl-containers/dev/associative.fasl written
; compilation finished in 0:00:26
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {100030C1}> on
   #<CL-SOURCE-FILE "associative" {100030D1}>.
STYLE-WARNING: implicitly creating new generic function SOME-KEY-VALUE-P
STYLE-WARNING: implicitly creating new generic function EVERY-KEY-VALUE-P
STYLE-WARNING: implicitly creating new generic function SEARCH-FOR-KEY
STYLE-WARNING: implicitly creating new generic function REMOVE-ITEMS-IF
STYLE-WARNING: implicitly creating new generic function COUNT-ITEMS
STYLE-WARNING: implicitly creating new generic function COUNT-ELEMENTS
STYLE-WARNING: implicitly creating new generic function COUNT-ELEMENTS-IF
STYLE-WARNING: implicitly creating new generic function PRINT-CONTAINER-SUMMARY
STYLE-WARNING: implicitly creating new generic function ITEM-AT-1
STYLE-WARNING: implicitly creating new generic function ITEM-AT-1!
STYLE-WARNING: implicitly creating new generic function (SETF ITEM-AT-1)
STYLE-WARNING: implicitly creating new generic function DELETE-ITEM-AT
STYLE-WARNING: implicitly creating new generic function INITIALIZE-CONTAINER
STYLE-WARNING: implicitly creating new generic function SORT-KEYS
STYLE-WARNING: implicitly creating new generic function SORT-CONTAINER
STYLE-WARNING: implicitly creating new generic function ITEM-KEY
; compiling file "/Users/gwking/darcs/cl-containers/dev/compatibility.lisp" (written 28 OCT 2005 12:17:49 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFMETHOD ITERATABLE-P ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; file: /Users/gwking/darcs/cl-containers/dev/compatibility.lisp
; in: DEFMETHOD COLLECT-ELEMENTS (LIST)
;     (IF METABANG.CL-CONTAINERS::TRANSFORM
;       (FUNCALL METABANG.CL-CONTAINERS::TRANSFORM METABANG.CL-CONTAINERS::ITEM)
;       METABANG.CL-CONTAINERS::ITEM)
; ==>
;   METABANG.CL-CONTAINERS::ITEM
; 
; note: deleting unreachable code

; compiling (DEFMETHOD ELEMENT-POSITION ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCH ...)
; compiling (DEPRECATED "Use collect-elements instead." ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD FIND-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-ELEMENT ...)
; compiling (DEFMETHOD REDUCE-ELEMENTS ...)
; compiling (DEFMETHOD SOME-ITEM-P ...)
; compiling (DEFMETHOD SOME-ELEMENT-P ...)
; compiling (DEFMETHOD EVERY-ITEM-P ...)
; compiling (DEFMETHOD EVERY-ELEMENT-P ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATABLE-P ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCH ...)
; compiling (DEPRECATED "Use collect-elements instead." ...)
; compiling (DEFMETHOD SOME-ITEM-P ...)
; compiling (DEFMETHOD SOME-ELEMENT-P ...)
; compiling (DEFMETHOD EVERY-ITEM-P ...)
; compiling (DEFMETHOD EVERY-ELEMENT-P ...)
; compiling (DEFMETHOD SORT-ELEMENTS ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATABLE-P ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFMETHOD SEARCH-FOR-MATCH ...)
; compiling (DEFMETHOD SOME-ELEMENT-P ...)
; compiling (DEFMETHOD EVERY-ELEMENT-P ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD ITERATABLE-P ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD COLLECT-KEYS ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD ITEM-AT-1 ...)
; compiling (DEFMETHOD ITEM-AT-1! ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)
; compiling (DEFMETHOD COLLECT-KEY-VALUE ...)

; /Users/gwking/darcs/cl-containers/dev/compatibility.fasl written
; compilation finished in 0:00:24
; compiling file "/Users/gwking/darcs/cl-containers/dev/vectors.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* VECTOR-CONTAINER-MIXIN ...)
; compiling (DEFMETHOD ITEM-AT ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFMETHOD NTH-ELEMENT ...)
; compiling (DEFMETHOD FIRST-ITEM ...)
; compiling (DEFMETHOD LAST-ITEM ...)
; compiling (DEFCLASS* BASIC-VECTOR-CONTAINER ...)
; compiling (DEFCLASS* BOUNDED-VECTOR-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCLASS* VECTOR-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM-AT ...)
; compiling (DEFMETHOD DELETE-ITEM-AT ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD DELETE-FIRST ...)
; compiling (DEFMETHOD DELETE-LAST ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFCLASS* FLEXIBLE-VECTOR-CONTAINER ...)
; compiling (DEFMETHOD ITEM-AT! ...)
; compiling (DEFUN RESIZE-VECTOR ...)
; compiling (DEFMETHOD SAMEP ...)

; /Users/gwking/darcs/cl-containers/dev/vectors.fasl written
; compilation finished in 0:00:07
; compiling file "/Users/gwking/darcs/cl-containers/dev/quad-tree.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* QUAD-TREE ...)
; compiling (DEFCLASS* FOUR-CHILD-NODE ...)
; compiling (DEFCLASS* QUAD-TREE-NODE ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD NODE-EMPTY-P ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFGENERIC NOTIFY-ELEMENT-OF-CHILD-STATUS ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD EMPTY-P ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFMETHOD FIND-ITEM ...)

; /Users/gwking/darcs/cl-containers/dev/quad-tree.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/darcs/cl-containers/dev/heaps.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* HEAP-CONTAINER ...)
; compiling (DEFCLASS* HEAP-NODE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFMETHOD L-CHILD ...)
; compiling (DEFMETHOD R-CHILD ...)
; compiling (DEFMETHOD HEAP-NODE-PARENT ...)
; compiling (DEFMETHOD L-CHILD-INDEX ...)
; compiling (DEFMETHOD R-CHILD-INDEX ...)
; compiling (DEFMETHOD NODE-PARENT-INDEX ...)
; compiling (DEFMETHOD EXCHANGE-HEAP-NODES ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD HEAPIFY ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD BIGGEST-ITEM ...)
; compiling (DEFMETHOD DELETE-BIGGEST-ITEM ...)
; compiling (DEFMETHOD DELETE-ITEM ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFCLASS* K-BEST-HEAP-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)

; /Users/gwking/darcs/cl-containers/dev/heaps.fasl written
; compilation finished in 0:00:12
; compiling file "/Users/gwking/darcs/cl-containers/dev/container-mixins.lisp" (written 30 OCT 2005 05:57:55 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFCLASS* FILTERED-CONTAINER-MIXIN ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD COLLECT-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-KEY-VALUE ...)

; /Users/gwking/darcs/cl-containers/dev/container-mixins.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/cl-containers/dev/union-find-container.lisp" (written 21 OCT 2005 03:54:52 PM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCLASS* UNION-FIND-NODE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFMETHOD MAKE-SET ...)
; compiling (DEFMETHOD GRAFT-NODES ...)
; compiling (DEFMETHOD FIND-SET ...)
; compiling (DEFMETHOD LINK-NODES ...)
; compiling (DEFCLASS* UNION-FIND-CONTAINER ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD REPRESENTATIVE ...)
; compiling (DEFMETHOD REPRESENTATIVE-NODE ...)

; /Users/gwking/darcs/cl-containers/dev/union-find-container.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/darcs/cl-containers/dev/package-container.lisp" (written 17 NOV 2005 08:07:29 AM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCLASS* PACKAGE-CONTAINER ...)
; compiling (DEFMETHOD (SETF PACKAGES) ...)
; compiling (DEFMETHOD (SETF PACKAGES) ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFUN BOUND-SYMBOLS-IN-PACKAGE ...)

; /Users/gwking/darcs/cl-containers/dev/package-container.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/darcs/cl-containers/dev/containers-readtable.lisp" (written 17 NOV 2005 08:04:58 AM):
; compiling (IN-PACKAGE CONTAINERS)
; compiling (DEFVAR *CONTAINER-READTABLE* ...)
; compiling (DEFVAR *CONTAINER-PRINT-REPRESENTATION* ...)
; compiling (DEFVAR *CONTAINER-PRINT-LENGTH* ...)
; compiling (DEFVAR *CONTAINER-PRINT-ASSOCIATION-STRING* ...)
; compiling (DEFVAR *CONTAINER-PRINT-ASSOCIATION-SEPARATOR* ...)
; compiling (SET-MACRO-CHARACTER #\[ ...)
; compiling (SET-MACRO-CHARACTER #\] ...)
; compiling (DEFMETHOD PRINT-CONTAINER-SUMMARY ...)
; compiling (DEFMETHOD PRINT-CONTAINER-CONTENTS ...)
; compiling (DEFMETHOD PRINT-CONTAINER-CONTENTS ...)
; compiling (DEFMETHOD PRINT-CONTAINER-CONTENTS ...)
; compiling (DEFCLASS* CONTAINER-PRINTING-MIXIN ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)

; /Users/gwking/darcs/cl-containers/dev/containers-readtable.fasl written
; compilation finished in 0:00:03
STYLE-WARNING: redefining BEST-ITEM in DEFGENERIC
STYLE-WARNING: redefining ARGMAX in DEFGENERIC
STYLE-WARNING: redefining ARGMIN in DEFGENERIC
STYLE-WARNING: redefining MAKE-NODE-FOR-CONTAINER in DEFGENERIC
STYLE-WARNING: redefining SIZE in DEFGENERIC
STYLE-WARNING: redefining EMPTY! in DEFGENERIC
STYLE-WARNING: redefining SOME-ITEM-P in DEFGENERIC
STYLE-WARNING: redefining EVERY-ITEM-P in DEFGENERIC
STYLE-WARNING: redefining MAKE-CONTAINER-FOR-CONTENTS in DEFGENERIC
STYLE-WARNING: redefining NTH-ELEMENT in DEFGENERIC
STYLE-WARNING: redefining TOTAL-SIZE in DEFGENERIC
STYLE-WARNING: redefining ITEM-AT in DEFGENERIC
STYLE-WARNING: redefining ITEM-AT! in DEFGENERIC
STYLE-WARNING: redefining FIND-ITEM in DEFGENERIC
STYLE-WARNING: redefining FIND-ELEMENT in DEFGENERIC
STYLE-WARNING: redefining SEARCH-FOR-ITEM in DEFGENERIC
STYLE-WARNING: redefining SEARCH-FOR-MATCH in DEFGENERIC
STYLE-WARNING: redefining ITERATE-NODES in DEFGENERIC
STYLE-WARNING: redefining PRINT-CONTAINER in DEFGENERIC
STYLE-WARNING: redefining COLLECT-NODES in DEFGENERIC
STYLE-WARNING: redefining COLLECT-ELEMENTS in DEFGENERIC
STYLE-WARNING: redefining COLLECT-KEY-VALUE in DEFGENERIC
STYLE-WARNING: redefining COLLECT-KEYS in DEFGENERIC
STYLE-WARNING: redefining ITERATE-KEY-VALUE in DEFGENERIC
STYLE-WARNING: redefining FIRST-ITEM in DEFGENERIC
STYLE-WARNING: redefining LAST-ITEM in DEFGENERIC
STYLE-WARNING: redefining INSERT-ITEM in DEFGENERIC
STYLE-WARNING: redefining APPEND-ITEM in DEFGENERIC
STYLE-WARNING: redefining INSERT-NEW-ITEM in DEFGENERIC
STYLE-WARNING: redefining APPEND-NEW-ITEM in DEFGENERIC
STYLE-WARNING: redefining INSERT-SEQUENCE in DEFGENERIC
STYLE-WARNING: redefining INSERT-LIST in DEFGENERIC
STYLE-WARNING: redefining DELETE-LIST in DEFGENERIC
STYLE-WARNING: redefining REVERSE-FIND in DEFGENERIC
STYLE-WARNING: redefining REMOVE-ITEMS-IF in DEFGENERIC
STYLE-WARNING: redefining ELEMENT-POSITION in DEFGENERIC
STYLE-WARNING: redefining DELETE-ITEM in DEFGENERIC
STYLE-WARNING: redefining DELETE-ITEM-IF in DEFGENERIC
STYLE-WARNING: implicitly creating new generic function ERROR-IF-QUEUE-EMPTY
STYLE-WARNING: implicitly creating new generic function DELETE-NODE
STYLE-WARNING: implicitly creating new generic function PUSH-ITEM
STYLE-WARNING: implicitly creating new generic function ITERATE-CHILDREN
STYLE-WARNING: implicitly creating new generic function HAS-CHILDREN-P
STYLE-WARNING: implicitly creating new generic function FIND-CHILD-NODE
STYLE-WARNING: implicitly creating new generic function INORDER-WALK
STYLE-WARNING: implicitly creating new generic function PREORDER-WALK
STYLE-WARNING: implicitly creating new generic function POSTORDER-WALK
STYLE-WARNING: implicitly creating new generic function INORDER-WALK-NODES
STYLE-WARNING: implicitly creating new generic function PREORDER-WALK-NODES
STYLE-WARNING: implicitly creating new generic function POSTORDER-WALK-NODES
STYLE-WARNING: implicitly creating new generic function WALK-TREE
STYLE-WARNING: implicitly creating new generic function WALK-TREE-NODES
STYLE-WARNING: implicitly creating new generic function ROTATE-LEFT
STYLE-WARNING: implicitly creating new generic function ROTATE-RIGHT
STYLE-WARNING: implicitly creating new generic function RB-DELETE-FIXUP
STYLE-WARNING: implicitly creating new generic function HEIGHT
STYLE-WARNING: implicitly creating new generic function UPDATE-ELEMENT
STYLE-WARNING: implicitly creating new generic function SET-DIRTY-FLAG
STYLE-WARNING: implicitly creating new generic function CLEAN-UP
STYLE-WARNING: implicitly creating new generic function INSERT-ITEM-AFTER
STYLE-WARNING: implicitly creating new generic function INSERT-ITEM-BEFORE
STYLE-WARNING: implicitly creating new generic function DELETE-ITEM-AFTER
STYLE-WARNING: implicitly creating new generic function DELETE-ITEM-BEFORE
STYLE-WARNING: implicitly creating new generic function REPLACE-ITEM
STYLE-WARNING: implicitly creating new generic function ITERATE-NODES-ABOUT-NODE
STYLE-WARNING:
   implicitly creating new generic function INSERT-ITEM-ORDERED-ABOUT-NODE
STYLE-WARNING: implicitly creating new generic function INSERT-ITEM-ORDERED
STYLE-WARNING: implicitly creating new generic function LEFT-NODE-FOR-ITEM
STYLE-WARNING: implicitly creating new generic function RIGHT-NODE-FOR-ITEM
STYLE-WARNING:
   implicitly creating new generic function LEFT-AND-RIGHT-NODES-FOR-ITEM
STYLE-WARNING: implicitly creating new generic function ITERATE-LEFT-NODES
STYLE-WARNING: implicitly creating new generic function ITERATE-RIGHT-NODES
STYLE-WARNING: implicitly creating new generic function ITERATE-LEFT
STYLE-WARNING: implicitly creating new generic function ITERATE-RIGHT
STYLE-WARNING: implicitly creating new generic function SORT-UPDATE-LEFT
STYLE-WARNING: implicitly creating new generic function SORT-UPDATE-RIGHT
STYLE-WARNING: implicitly creating new generic function UPDATE-ITEM
STYLE-WARNING: implicitly creating new generic function INCREMENT-END
STYLE-WARNING: implicitly creating new generic function CURRENT-ITEM
STYLE-WARNING: redefining NTH-ELEMENT (ARRAY NUMBER) in DEFMETHOD
STYLE-WARNING: implicitly creating new generic function INSERT-ITEM-AT
STYLE-WARNING: implicitly creating new generic function L-CHILD
STYLE-WARNING: implicitly creating new generic function R-CHILD
STYLE-WARNING: implicitly creating new generic function HEAP-NODE-PARENT
STYLE-WARNING: implicitly creating new generic function L-CHILD-INDEX
STYLE-WARNING: implicitly creating new generic function R-CHILD-INDEX
STYLE-WARNING: implicitly creating new generic function NODE-PARENT-INDEX
STYLE-WARNING: implicitly creating new generic function EXCHANGE-HEAP-NODES
STYLE-WARNING: implicitly creating new generic function HEAPIFY
STYLE-WARNING: implicitly creating new generic function BIGGEST-ITEM
STYLE-WARNING: implicitly creating new generic function DELETE-BIGGEST-ITEM
STYLE-WARNING: implicitly creating new generic function MAKE-SET
STYLE-WARNING: implicitly creating new generic function GRAFT-NODES
STYLE-WARNING: implicitly creating new generic function FIND-SET
STYLE-WARNING: implicitly creating new generic function LINK-NODES
STYLE-WARNING: implicitly creating new generic function REPRESENTATIVE
STYLE-WARNING: implicitly creating new generic function REPRESENTATIVE-NODE
STYLE-WARNING: implicitly creating new generic function (SETF PACKAGES)
STYLE-WARNING: implicitly creating new generic function PRINT-CONTAINER-CONTENTS
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/package.lisp" (written 17 NOV 2005 12:09:42 PM):
; compiling (IN-PACKAGE COMMON-LISP-USER)
; compiling (DEFPACKAGE "CL-MATHSTATS" ...)

; /Users/gwking/darcs/cl-mathstats/dev/package.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/math-utilities.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DECLAIM (INLINE ENSURE-FLOAT))
; compiling (DEFUN ENSURE-FLOAT ...)
; compiling (DEFUN LINEAR-SCALE ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN TRUNCATE-TO-FACTOR ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN ROUND-TO-FACTOR ...)
; compiling (DEFCONSTANT FPI ...)
; compiling (DEFCONSTANT 2FPI ...)
; compiling (DEFCONSTANT +E+ ...)
; compiling (DEFUN DEGREES->RADIANS ...)
; compiling (DEFUN RADIANS->DEGREES ...)
; compiling (DEFUN ON-INTERVAL ...)
; compiling (DEFUN COMBINATION-COUNT ...)
; compiling (DEFUN PERMUTATION-COUNT ...)
; compiling (DECLAIM (INLINE SQUARE))
; compiling (DEFUN SQUARE ...)
; compiling (DEFUN F-MEASURE ...)

; /Users/gwking/darcs/cl-mathstats/dev/math-utilities.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/definitions.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCONSTANT +0DEGREES+ ...)
; compiling (DEFCONSTANT +5DEGREES+ ...)
; compiling (DEFCONSTANT +10DEGREES+ ...)
; compiling (DEFCONSTANT +15DEGREES+ ...)
; compiling (DEFCONSTANT +30DEGREES+ ...)
; compiling (DEFCONSTANT +45DEGREES+ ...)
; compiling (DEFCONSTANT +60DEGREES+ ...)
; compiling (DEFCONSTANT +90DEGREES+ ...)
; compiling (DEFCONSTANT +120DEGREES+ ...)
; compiling (DEFCONSTANT +135DEGREES+ ...)
; compiling (DEFCONSTANT +150DEGREES+ ...)
; compiling (DEFCONSTANT +180DEGREES+ ...)
; compiling (DEFCONSTANT +210DEGREES+ ...)
; compiling (DEFCONSTANT +225DEGREES+ ...)
; compiling (DEFCONSTANT +240DEGREES+ ...)
; compiling (DEFCONSTANT +270DEGREES+ ...)
; compiling (DEFCONSTANT +300DEGREES+ ...)
; compiling (DEFCONSTANT +315DEGREES+ ...)
; compiling (DEFCONSTANT +330DEGREES+ ...)
; compiling (DEFCONSTANT +360DEGREES+ ...)

; /Users/gwking/darcs/cl-mathstats/dev/definitions.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/binary-math.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN TIMES2 ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN DIV2 ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN EXP2 ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN LOG2 ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN TRUNC2 ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN MOD2 ...)

; /Users/gwking/darcs/cl-mathstats/dev/binary-math.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/matrices.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFMACRO CHECK-TYPE-OF-ARG ...)
; compiling (DEFUN SCALAR-MATRIX-MULTIPLY ...)
; compiling (DEFUN 1-OR-2D-ARRAYP ...)
; compiling (DEFUN LIST-2D-ARRAY ...)
; compiling (DEFUN FILL-2D-ARRAY ...)
; compiling (DEFUN MULTIPLY-MATRICES ...)
; compiling (DEFUN INVERT-MATRIX ...)
; compiling (DEFUN MATRIX-NORM ...)
; compiling (DEFUN INVERT-MATRIX-ITERATE ...)
; compiling (DEFUN TRANSPOSE-MATRIX ...)
; compiling (DEFUN NORMALIZE-MATRIX ...)
; compiling (DEFUN SUM-OF-ARRAY-ELEMENTS ...)

; /Users/gwking/darcs/cl-mathstats/dev/matrices.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/matrix-fns.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFUN MATRIX-TRACE ...)
; compiling (DEFUN MATRIX-MULTIPLY ...)
; compiling (DEFUN MATRIX-TIMES-SCALAR! ...)
; compiling (DEFUN MATRIX-TIMES-SCALAR ...)
; compiling (DEFUN MATRIX-TIMES-MATRIX ...)
; compiling (DEFUN MATRIX-ADDITION ...)
; compiling (DEFUN MATRIX-PLUS-SCALAR ...)
; compiling (DEFUN MATRIX-PLUS-MATRIX ...)
; compiling (DEFUN REDUCE-MATRIX ...)

; /Users/gwking/darcs/cl-mathstats/dev/matrix-fns.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/density-fns.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFPARAMETER *GAUSSIAN-CDF-SIGNALS-ZERO-STANDARD-DEVIATION-ERROR* ...)
; compiling (DEFCONSTANT +LOG-PI+ ...)
; compiling (DEFCONSTANT +SQRT-PI+ ...)
; compiling (DEFUN GAMMA-LN ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/density-fns.lisp
; in: DEFUN GAMMA-LN
;     (LOG (SIN (* PI CL-MATHSTATS::Z)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT))
;                           &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (+ (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
;      (LOG (SIN (* PI CL-MATHSTATS::Z))))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a SINGLE-FLOAT.
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX
;                                                                DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a REAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a REAL.
;   The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX
;                                                                DOUBLE-FLOAT).

;     (- (+ (LOG CL-MATHSTATS::Z) CL-MATHSTATS::+LOG-PI+)
;      (+ (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
;         (LOG (SIN (* PI CL-MATHSTATS::Z)))))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LOG (* 2.50662827465d0 CL-MATHSTATS::SER))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT))
;                           &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (- (LOG (* 2.50662827465d0 CL-MATHSTATS::SER)) CL-MATHSTATS::TMP)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR DOUBLE-FLOAT
;                               (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX
;                                                               DOUBLE-FLOAT).

;     (+ (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
;      (LOG (SIN (* PI CL-MATHSTATS::Z))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT * 0.0d0)
;                                    (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (- (+ (LOG CL-MATHSTATS::Z) CL-MATHSTATS::+LOG-PI+)
;      (+ (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
;         (LOG (SIN (* PI CL-MATHSTATS::Z)))))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (- (LOG (* 2.50662827465d0 CL-MATHSTATS::SER)) CL-MATHSTATS::TMP)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT
;                                   (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) DOUBLE-FLOAT)
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (LOG (* 2.50662827465d0 CL-MATHSTATS::SER))
; 
; note: doing float to pointer coercion (cost 13)

;     (- (LOG (* 2.50662827465d0 CL-MATHSTATS::SER)) CL-MATHSTATS::TMP)
; 
; note: doing float to pointer coercion (cost 13) from TMP, for:
;       the second argument of GENERIC--

;     (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (LOG (SIN (* PI CL-MATHSTATS::Z)))
; 
; note: doing float to pointer coercion (cost 13)

;     (- (+ (LOG CL-MATHSTATS::Z) CL-MATHSTATS::+LOG-PI+)
;      (+ (CL-MATHSTATS::GAMMA-LN (+ 1.0d0 CL-MATHSTATS::Z))
;         (LOG (SIN (* PI CL-MATHSTATS::Z)))))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC--

; compiling (DEFUN FACTORIAL-EXACT ...)
; compiling (DEFUN FACTORIAL ...)
; compiling (DEFUN FACTORIAL-LN ...)
; compiling (DEFUN BINOMIAL-COEFFICIENT ...)
; compiling (DEFUN BINOMIAL-COEFFICIENT-EXACT ...)
; compiling (DEFUN BINOMIAL-PROBABILITY ...)
; compiling (DEFUN BINOMIAL-PROBABILITY-EXACT ...)
; compiling (DEFUN BETA ...)
; compiling (DEFUN SAFE-EXP ...)
; compiling (DEFMACRO UNDERFLOW-GOES-TO-ZERO ...)
; compiling (DEFUN GAMMA-INCOMPLETE ...)
; compiling (DEFUN ERROR-FUNCTION ...)
; compiling (DEFUN GAUSSIAN-CDF ...)
; compiling (DEFUN ERROR-FUNCTION-COMPLEMENT ...)
; compiling (DEFUN ERROR-FUNCTION-COMPLEMENT-SHORT-1 ...)
; compiling (DEFUN ERROR-FUNCTION-COMPLEMENT-SHORT-2 ...)
; compiling (DEFUN GAUSSIAN-SIGNIFICANCE ...)
; compiling (DEFUN POISSON-CDF ...)
; compiling (DEFUN CHI-SQUARE-SIGNIFICANCE ...)
; compiling (DEFUN BETA-INCOMPLETE ...)
; compiling (DEFUN STUDENTS-T-SIGNIFICANCE ...)
; compiling (DEFUN F-SIGNIFICANCE ...)
; compiling (DEFUN BINOMIAL-CDF ...)
; compiling (DEFUN BINOMIAL-CDF-EXACT ...)

; /Users/gwking/darcs/cl-mathstats/dev/density-fns.fasl written
; compilation finished in 0:00:06
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/svd.lisp" (written 21 OCT 2005 03:54:56 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFMACRO AREF1 ...)
; compiling (DEFMACRO AREF11 ...)
; compiling (DEFMACRO SIGN-DF ...)
; compiling (DEFUN PYTHAG-DF ...)
; compiling (DEFUN SVBKSB-DF ...)
; compiling (DEFUN SVDCMP-DF ...)
; compiling (DEFUN SVZERO-DF ...)
; compiling (DEFUN SVD-INVERSE-SLOW-DF ...)
; compiling (DEFUN SVD-INVERSE-FAST-DF ...)
; compiling (DEFMACRO SIGN-SF ...)
; compiling (DEFUN PYTHAG-SF ...)
; compiling (DEFUN SVBKSB-SF ...)
; compiling (DEFUN SVDCMP-SF ...)
; compiling (DEFUN SVZERO-SF ...)
; compiling (DEFUN SVD-INVERSE-SLOW-SF ...)
; compiling (DEFUN SVD-INVERSE-FAST-SF ...)
; compiling (DEFUN SINGULAR-VALUE-DECOMPOSITION ...)
; compiling (DEFUN SVD-ZERO ...)
; compiling (DEFUN SVD-BACK-SUBSTITUTE ...)
; compiling (DEFUN SVD-SOLVE-LINEAR-SYSTEM ...)
; compiling (DEFUN SVDVAR ...)
; compiling (DEFUN SVD-MATRIX-INVERSE ...)

; /Users/gwking/darcs/cl-mathstats/dev/svd.fasl written
; compilation finished in 0:00:15
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/parameters.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFPARAMETER *GAUSSIAN-CDF-SIGNALS-ZERO-STANDARD-DEVIATION-ERROR* ...)

; /Users/gwking/darcs/cl-mathstats/dev/parameters.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/utilities.lisp" (written 21 OCT 2005 03:54:56 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFVAR *TEMPORARY-VECTOR* ...)
; compiling (DEFMACRO WITH-TEMP-VECTOR ...)
; compiling (DEFVAR *TEMPORARY-TABLE* ...)
; compiling (DEFMACRO WITH-TEMP-TABLE ...)
; compiling (DEFUN EXTRACT-UNIQUE-VALUES ...)

; /Users/gwking/darcs/cl-mathstats/dev/utilities.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/define-statistical-fun.lisp" (written 17 NOV 2005 01:48:14 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFMACRO WITH-ROUTINE-ERROR-HANDLING ...)
; compiling (DEFMACRO DEFINE-STATISTIC ...)
; compiling (DEFUN REMOVE-&REST ...)
; compiling (DEFMETHOD MAKE-STATISTIC ...)
; compiling (DEFMETHOD CONVERT ...)
; compiling (DEFPARAMETER *CREATE-STATISTICAL-OBJECTS* ...)
; compiling (DEFCLASS DATA ...)
; compiling (DEFCLASS STATISTIC ...)
; compiling (DEFCLASS SIMPLE-STATISTIC ...)
; compiling (DEFCLASS COMPOSITE-STATISTIC ...)
; compiling (DEFMETHOD STATISTICP ...)
; compiling (DEFMETHOD STATISTICP ...)
; compiling (DEFMETHOD COMPOSITE-STATISTIC-P ...)
; compiling (DEFMETHOD COMPOSITE-STATISTIC-P ...)
; compiling (DEFMETHOD SIMPLE-STATISTIC-P ...)
; compiling (DEFMETHOD SIMPLE-STATISTIC-P ...)

; /Users/gwking/darcs/cl-mathstats/dev/define-statistical-fun.fasl written
; compilation finished in 0:00:06
STYLE-WARNING: implicitly creating new generic function MAKE-STATISTIC
STYLE-WARNING: implicitly creating new generic function CONVERT
STYLE-WARNING: implicitly creating new generic function STATISTICP
STYLE-WARNING: implicitly creating new generic function COMPOSITE-STATISTIC-P
STYLE-WARNING: implicitly creating new generic function SIMPLE-STATISTIC-P
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp" (written 11 NOV 2005 05:17:02 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFMETHOD CONVERT ...)
; compiling (DEFMETHOD CONVERT ...)
; compiling (DEFINE-STATISTIC DATA-LENGTH ...)
; compiling (DEFINE-STATISTIC MEAN ...)
; compiling (DEFUN SUM-OF-SQUARES ...)
; compiling (DEFINE-STATISTIC VARIANCE ...)
; compiling (DEFINE-STATISTIC STANDARD-DEVIATION ...)
; compiling (DEFINE-STATISTIC SKEWNESS ...)
; compiling (DEFINE-STATISTIC MINIMUM ...)
; compiling (DEFINE-STATISTIC MAXIMUM ...)
; compiling (DEFINE-STATISTIC RANGE ...)
; compiling (DEFINE-STATISTIC QUANTILE ...)
; compiling (DEFINE-STATISTIC MEDIAN ...)
; compiling (DEFINE-STATISTIC TRIMMED-MEAN ...)
; compiling (DEFMACRO START/END ...)
; compiling (DEFINE-STATISTIC MODE ...)
; compiling (DEFPARAMETER *CONTINUOUS-VARIABLE-UNIQUENESS-FACTOR* ...)
; compiling (DEFPARAMETER *CONTINOUS-DATA-WINDOW-DIVISOR* ...)
; compiling (DEFUN MODE-FOR-CONTINUOUS-DATA ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN MODE-FOR-CONTINUOUS-DATA
;     (DEFUN CL-MATHSTATS::MODE-FOR-CONTINUOUS-DATA
;          (CL-MATHSTATS::DATA
;           &REST CL-MATHSTATS::STANDARD-ARGS
;           &KEY CL-MATHSTATS::START CL-MATHSTATS::END CL-MATHSTATS::KEY
;           CL-MATHSTATS::WINDOW)
;     "Returns the most frequent element of `data,' which should be a sequence.  The
; algorithm involves sorting, and so the data must be numbers or the `key'
; function must produce numbers.  Consider `sxhash' if no better function is
; available.  Also returns the number of occurrences of the mode.  If there is
; more than one mode, this returns the first mode, as determined by the sorting of
; the numbers.
; 
; Keep in mind that if the data has multiple runs of like values that are bigger
; than the window size (currently defaults to 10% of the size of the data) this
; function will blindly pick the first one. If this is the case you probabaly
; should be calling `mode' instead of this function."
;     (DECLARE
;      (VALUES METABANG.UTILITIES:ELEMENT CL-MATHSTATS::NUMBER-OF-OCCURRENCES))
;     (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;     (WHEN (NOT (CL-MATHSTATS::DATA-CONTINUOUS-P CL-MATHSTATS::DATA))
;       (WARN 'CL-MATHSTATS::SEEMS-TO-BE-DISCRETE))
;     (LET* ((CL-MATHSTATS::N
;             (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                    CL-MATHSTATS::DATA
;                    :ALLOW-OTHER-KEYS
;                    T
;                    CL-MATHSTATS::STANDARD-ARGS))
;            (CL-MATHSTATS::START2 (OR CL-MATHSTATS::START 0))
;            (CL-MATHSTATS::END2 (OR CL-MATHSTATS::END #))
;            (CL-MATHSTATS::J (OR CL-MATHSTATS::WINDOW #)))
;       (WHEN (ZEROP CL-MATHSTATS::N) (ERROR 'CL-MATHSTATS::NO-DATA))
;       (CL-MATHSTATS::WITH-TEMP-VECTOR (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                                       (REPLACE CL-MATHSTATS::TEMP
;                                                CL-MATHSTATS::DATA
;                                                :END1
;                                                CL-MATHSTATS::N
;                                                :START2
;                                                CL-MATHSTATS::START2
;                                                :END2
;                                                CL-MATHSTATS::END2)
;                                       (IF (NULL CL-MATHSTATS::KEY)
;                                           (SORT CL-MATHSTATS::TEMP #'<)
;                                           (SORT CL-MATHSTATS::TEMP
;                                                 #'<
;                                                 :KEY
;                                                 CL-MATHSTATS::KEY))
;                                       (MACROLET (#)
;                                         (IF CL-MATHSTATS::KEY # #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION 
; ==>
;   (THE
;    #<SB-KERNEL:VALUES-TYPE (VALUES &OPTIONAL
;                                    METABANG.UTILITIES:ELEMENT
;                                    CL-MATHSTATS::NUMBER-OF-OCCURRENCES
;                                    &REST
;                                    T)>
;    (PROGN
;     (BLOCK CL-MATHSTATS::MODE-FOR-CONTINUOUS-DATA
;       (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;       (WHEN (NOT #) (WARN 'CL-MATHSTATS::SEEMS-TO-BE-DISCRETE))
;       (LET* (# # # #)
;         (WHEN # #)
;         (CL-MATHSTATS::WITH-TEMP-VECTOR # # # #)))))
; 
; note: type assertion too complex to check:
;  (VALUES &OPTIONAL ELEMENT NUMBER-OF-OCCURRENCES &REST T).

; compiling (DEFUN DATA-CONTINUOUS-P ...)
; compiling (DEFUN SMART-MODE ...)
; compiling (DEFINE-STATISTIC MULTIPLE-MODES ...)
; compiling (DEFINE-STATISTIC INTERQUARTILE-RANGE ...)
; compiling (DEFINE-STATISTIC TUKEY-SUMMARY ...)
; compiling (DEFINE-STATISTIC STATISTICAL-SUMMARY ...)
; compiling (DEFINE-STATISTIC SIGNIFICANCE ...)
; compiling (DEFINE-STATISTIC T-SIGNIFICANCE ...)
; compiling (DEFINE-STATISTIC T-TEST-ONE-SAMPLE ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFINE-STATISTIC T-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::T-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::T-SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the t-statistic for the mean of the data, which should be a sequence
; of numbers.  Let D be the sample mean.  The null hypothesis is that D equals the
; `H0-mean.' The alternative hypothesis is specified by `tails': `:both' means D
; /= H0-mean, `:positive' means D > H0-mean, and `:negative' means D < H0-mean.
; 
; The function also returns the significance, the standard error, and the degrees
; of freedom.  Signals `zero-variance' if that condition occurs.  Signals
; `insufficient-data' unless there are at least two elements in the sample."
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY)
;                                    (VALUES CL-MATHSTATS::T-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            CL-MATHSTATS::SAMPLE-ERROR
;                                            CL-MATHSTATS::DOF))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# # #)
;                                         (VALUES CL-MATHSTATS::TT
;                                                 CL-MATHSTATS::SIG
;                                                 CL-MATHSTATS::SE
;                                                 #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY)
;                           (VALUES CL-MATHSTATS::T-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::SAMPLE-ERROR
;                                   CL-MATHSTATS::DOF))
;                          (BLOCK CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (DATA TAILS
;                                                           &OPTIONAL
;                                                           (H0-MEAN 0)
;                                                           &REST
;                                                           STANDARD-ARGS
;                                                           &KEY
;                                                           START
;                                                           END
;                                                           KEY)

; compiling (DEFINE-STATISTIC T-TEST ...)
; compiling (DEFINE-STATISTIC D-TEST ...)
; compiling (DEFINE-STATISTIC T-TEST-MATCHED ...)
; compiling (DEFINE-STATISTIC Z-TEST-ONE-SAMPLE ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFINE-STATISTIC Z-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::Z-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       (CL-MATHSTATS::H0-STD-DEV
;                                                        1)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY
;                                            CL-MATHSTATS::TAILS)
;                                    (VALUES CL-MATHSTATS::Z-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# CL-MATHSTATS::SIG)
;                                         (VALUES CL-MATHSTATS::ZS
;                                                 CL-MATHSTATS::SIG)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::Z-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              (CL-MATHSTATS::H0-STD-DEV 1)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY
;                                   CL-MATHSTATS::TAILS)
;                           (VALUES CL-MATHSTATS::Z-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE))
;                          (BLOCK CL-MATHSTATS::Z-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   &OPTIONAL and &KEY found in the same lambda list: (DATA TAILS
;                                                           &OPTIONAL
;                                                           (H0-MEAN 0)
;                                                           (H0-STD-DEV 1)
;                                                           &REST
;                                                           STANDARD-ARGS
;                                                           &KEY
;                                                           START
;                                                           END
;                                                           KEY)

; compiling (DEFUN INNER-PRODUCT ...)
; compiling (DEFINE-STATISTIC COVARIANCE ...)
; compiling (DEFINE-STATISTIC CONFIDENCE-INTERVAL ...)
; compiling (DEFINE-STATISTIC CONFIDENCE-INTERVAL-Z ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFINE-STATISTIC CONFIDENCE-INTERVAL-Z
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::CONFIDENCE-INTERVAL-Z
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                                   "Suppose you have a sample of 50 numbers and you want to compute a 90 percent
; confidence interval on the population mean.  This function is the one to use.
; Note that it makes the assumption that the sampling distribution is normal, so
; it's inappropriate for small sample sizes.  Use confidence-interval-t instead.
; It returns three values: the mean and the lower and upper bound of the
; confidence interval.  True, only two numbers are necessary, but the confidence
; intervals of other statistics may be asymmetrical and these values would be
; consistent with those confidence intervals.  This function handles 90, 95 and 99
; percent confidence intervals as special cases, so those will be quite fast.
; `Sample' should be a sequence of numbers.  `Confidence' should be a number
; between 0 and 1, exclusive."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MEAN
;                                            CL-MATHSTATS::LOWER
;                                            CL-MATHSTATS::UPPER))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::CONFIDENCE
;                                               (REAL (0) (1)))
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                                    (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                                    (SQRT
;                                     (/
;                                      (CL-MATHSTATS::VARIANCE
;                                       CL-MATHSTATS::DATA)
;                                      (LENGTH CL-MATHSTATS::DATA)))
;                                    CL-MATHSTATS::CONFIDENCE))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION 
; ==>
;   (THE
;    #<SB-KERNEL:VALUES-TYPE (VALUES &OPTIONAL
;                                    CL-MATHSTATS::MEAN
;                                    CL-MATHSTATS::LOWER
;                                    CL-MATHSTATS::UPPER
;                                    &REST
;                                    T)>
;    (PROGN
;     (BLOCK CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-INTERNAL
;       (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;       (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL # #))
;       (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;        (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;        (SQRT #)
;        CL-MATHSTATS::CONFIDENCE))))
; 
; note: type assertion too complex to check:
;  (VALUES &OPTIONAL MEAN LOWER UPPER &REST T).

; compiling (DEFUN CONFIDENCE-INTERVAL-Z-SUMMARIES ...)
; compiling (DEFINE-STATISTIC CONFIDENCE-INTERVAL-T ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFINE-STATISTIC CONFIDENCE-INTERVAL-T
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::CONFIDENCE-INTERVAL-T
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                                   "Suppose you have a sample of 10 numbers and you want to compute a 90 percent
; confidence interval on the population mean.  This function is the one to use.
; This function uses the t-distribution, and so it is appropriate for small sample
; sizes.  It can also be used for large sample sizes, but the function
; `confidence-interval-z' may be computationally faster.  It returns three values:
; the mean and the lower and upper bound of the confidence interval.  True, only
; two numbers are necessary, but the confidence intervals of other statistics may
; be asymmetrical and these values would be consistent with those confidence
; intervals.  `Sample' should be a sequence of numbers.  `Confidence' should be a
; number between 0 and 1, exclusive."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MEAN
;                                            CL-MATHSTATS::LOWER
;                                            CL-MATHSTATS::UPPER))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::CONFIDENCE
;                                               (REAL (0) (1)))
;                                   (LET* ((CL-MATHSTATS::N
;                                           (LENGTH CL-MATHSTATS::DATA)))
;                                     (CL-MATHSTATS::CONFIDENCE-INTERVAL-T-SUMMARIES
;                                      (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                                      (- CL-MATHSTATS::N 1)
;                                      (SQRT (/ # CL-MATHSTATS::N))
;                                      CL-MATHSTATS::CONFIDENCE)))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION 
; ==>
;   (THE
;    #<SB-KERNEL:VALUES-TYPE (VALUES &OPTIONAL
;                                    CL-MATHSTATS::MEAN
;                                    CL-MATHSTATS::LOWER
;                                    CL-MATHSTATS::UPPER
;                                    &REST
;                                    T)>
;    (PROGN
;     (BLOCK CL-MATHSTATS::CONFIDENCE-INTERVAL-T-INTERNAL
;       (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;       (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL # #))
;       (LET* (#)
;         (CL-MATHSTATS::CONFIDENCE-INTERVAL-T-SUMMARIES #
;                                                        #
;                                                        #
;                                                        CL-MATHSTATS::CONFIDENCE)))))
; 
; note: type assertion too complex to check:
;  (VALUES &OPTIONAL MEAN LOWER UPPER &REST T).

; compiling (DEFUN CONFIDENCE-INTERVAL-T-SUMMARIES ...)
; compiling (DEFINE-STATISTIC CONFIDENCE-INTERVAL-PROPORTION ...)
; compiling (DEFUN SCHEFFE-TESTS ...)
; compiling (DEFUN PRINT-SCHEFFE-TABLE ...)
; compiling (DEFMETHOD CROSS-PRODUCT ...)
; compiling (DEFUN R-SCORE ...)
; compiling (DEFUN DIFFERENCE-LIST ...)
; compiling (DEFUN SUM-LIST ...)
; compiling (DEFUN CHI-SQUARE-2X2-COUNTS ...)
; compiling (DEFUN CHI-SQUARE-2X2 ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CHI-SQUARE-2X2
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2 (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables with only two values; the function
; will construct a 2x2 contingency table by counting the number of occurrences of
; each combination of the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTINGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (UNLESS (EQUAL '(2 2) (ARRAY-DIMENSIONS CL-MATHSTATS::2X2-TABLE))
;         (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;       (LET ((CL-MATHSTATS::A #)
;             (CL-MATHSTATS::B #)
;             (CL-MATHSTATS::C #)
;             (CL-MATHSTATS::D #))
;         (MULTIPLE-VALUE-CALL #'VALUES
;           (CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS CL-MATHSTATS::A
;                                                CL-MATHSTATS::B
;                                                CL-MATHSTATS::C
;                                                CL-MATHSTATS::D)
;           CL-MATHSTATS::2X2-TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION 
; ==>
;   (THE
;    #<SB-KERNEL:VALUES-TYPE (VALUES &OPTIONAL
;                                    CL-MATHSTATS::CHI-SQUARE
;                                    CL-MATHSTATS::SIGNIFICANCE
;                                    CL-MATHSTATS::CONTINGENCY-TABLE
;                                    CL-MATHSTATS::V1-VALUES
;                                    CL-MATHSTATS::V2-VALUES
;                                    &REST
;                                    T)>
;    (PROGN
;     (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2
;       (MULTIPLE-VALUE-BIND
;           (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                    CL-MATHSTATS::V2-VALUES)
;           (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                                 CL-MATHSTATS::V2)
;         (UNLESS # #)
;         (LET #
;           #)))))
; 
; note: type assertion too complex to check:
;  (VALUES &OPTIONAL
;          CHI-SQUARE
;          SIGNIFICANCE
;          CONTINGENCY-TABLE
;          V1-VALUES
;          V2-VALUES
;          &REST
;          T).

; compiling (DEFUN CHI-SQUARE-RXC-COUNTS ...)
; compiling (DEFVAR *WAY-TOO-BIG-CONTINGENCY-TABLE-DIMENSION* ...)
; compiling (DEFUN MAKE-CONTINGENCY-TABLE ...)
; compiling (DEFUN CHI-SQUARE-RXC ...)
; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CHI-SQUARE-RXC
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-RXC (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables; the function will construct a
; contingency table by counting the number of occurrences of each combination of
; the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTIGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (CHECK-TYPE CL-MATHSTATS::V1 SEQUENCE)
;     (CHECK-TYPE CL-MATHSTATS::V2 SEQUENCE)
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::TABLE CL-MATHSTATS::V1-VALUES CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (MULTIPLE-VALUE-CALL #'VALUES
;         (CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS CL-MATHSTATS::TABLE)
;         (CL-MATHSTATS::G-TEST CL-MATHSTATS::TABLE NIL NIL)
;         CL-MATHSTATS::TABLE
;         CL-MATHSTATS::V1-VALUES
;         CL-MATHSTATS::V2-VALUES)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION 
; ==>
;   (THE
;    #<SB-KERNEL:VALUES-TYPE (VALUES &OPTIONAL
;                                    CL-MATHSTATS::CHI-SQUARE
;                                    CL-MATHSTATS::SIGNIFICANCE
;                                    CL-MATHSTATS::CONTIGENCY-TABLE
;                                    CL-MATHSTATS::V1-VALUES
;                                    CL-MATHSTATS::V2-VALUES
;                                    &REST
;                                    T)>
;    (PROGN
;     (BLOCK CL-MATHSTATS::CHI-SQUARE-RXC
;       (CHECK-TYPE CL-MATHSTATS::V1 SEQUENCE)
;       (CHECK-TYPE CL-MATHSTATS::V2 SEQUENCE)
;       (MULTIPLE-VALUE-BIND
;           (CL-MATHSTATS::TABLE CL-MATHSTATS::V1-VALUES CL-MATHSTATS::V2-VALUES)
;           (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                                 CL-MATHSTATS::V2)
;         (MULTIPLE-VALUE-CALL #'VALUES
;           #
;           #
;           CL-MATHSTATS::TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES)))))
; 
; note: type assertion too complex to check:
;  (VALUES &OPTIONAL
;          CHI-SQUARE
;          SIGNIFICANCE
;          CONTIGENCY-TABLE
;          V1-VALUES
;          V2-VALUES
;          &REST
;          T).

; compiling (DEFUN G-TEST ...)
; compiling (DEFUN FIND-CRITICAL-VALUE ...)

; /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.fasl written
; compilation finished in 0:00:17
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10002FF1}> on
   #<CL-SOURCE-FILE "basic-statistics" {10003001}>.
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/smoothing.lisp" (written 21 OCT 2005 03:54:56 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFUN SMOOTH-MEDIAN-2 ...)
; compiling (DEFUN SMOOTH-MEDIAN-3 ...)
; compiling (DEFUN SMOOTH-MEDIAN-4 ...)
; compiling (DEFUN SMOOTH-MEDIAN-5 ...)
; compiling (DEFUN SMOOTH-HANNING ...)
; compiling (DEFUN SMOOTH-4253H ...)
; compiling (DEFUN SMOOTH-MEAN-2 ...)
; compiling (DEFUN SMOOTH-MEAN-3 ...)
; compiling (DEFUN SMOOTH-MEAN-4 ...)
; compiling (DEFUN SMOOTH-MEAN-5 ...)

; /Users/gwking/darcs/cl-mathstats/dev/smoothing.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp" (written 21 OCT 2005 03:54:55 PM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFINE-STATISTIC CORRELATION ...)
; compiling (DEFUN CORRELATION-FROM-SUMMARIES ...)
; compiling (DEFUN PARTIALS-FROM-PARENTS ...)
; compiling (DEFUN LAGGED-CORRELATION ...)
; compiling (DEFINE-STATISTIC CROSS-CORRELATION ...)
; compiling (DEFINE-STATISTIC AUTOCORRELATION ...)
; compiling (DEFUN LINEAR-REGRESSION-MINIMAL-SUMMARIES ...)
; compiling (DEFUN LINEAR-REGRESSION-MINIMAL ...)
; compiling (DEFUN LINEAR-REGRESSION-BRIEF-SUMMARIES ...)
; compiling (DEFUN LINEAR-REGRESSION-BRIEF ...)
; compiling (DEFUN LINEAR-REGRESSION-VERBOSE-SUMMARIES ...)
; compiling (DEFUN LINEAR-REGRESSION-VERBOSE ...)
; compiling (DEFUN MULTIPLE-LINEAR-REGRESSION-NORMAL ...)
; compiling (DEFUN MULTIPLE-LINEAR-REGRESSION-ARRAYS ...)
; compiling (DEFUN MULTIPLE-LINEAR-REGRESSION-MINIMAL ...)
; compiling (DEFUN MULTIPLE-LINEAR-REGRESSION-BRIEF ...)
; compiling (DEFUN MULTIPLE-LINEAR-REGRESSION-VERBOSE ...)
; compiling (DEFUN CORRELATION-MATRIX ...)

; /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.fasl written
; compilation finished in 0:00:06
; compiling file "/Users/gwking/darcs/cl-mathstats/dev/anova.lisp" (written 17 NOV 2005 11:14:07 AM):
; compiling (IN-PACKAGE METABANG.MATH)
; compiling (DEFINE-STATISTIC ANOVA-ONE-WAY-VARIABLES ...)
; compiling (DEFUN ANOVA-ONE-WAY-GROUPS ...)
; compiling (DEFUN PRINT-ANOVA-TABLE ...)
; compiling (DEFUN ANOVA-TWO-WAY-GROUPS ...)
; compiling (DEFUN MAKE-3D-TABLE ...)
; compiling (DEFINE-STATISTIC ANOVA-TWO-WAY-VARIABLES-UNEQUAL-CELL-SIZES ...)
; compiling (DEFINE-STATISTIC ANOVA-TWO-WAY-VARIABLES ...)

; /Users/gwking/darcs/cl-mathstats/dev/anova.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/darcs/metabang.bind/dev/bind.lisp" (written 21 OCT 2005 03:54:53 PM):
; compiling (DEFPACKAGE "METABANG.BIND" ...)
; compiling (IN-PACKAGE METABANG.BIND)
; compiling (DEFPARAMETER *BIND-ALL-DECLARATIONS* ...)
; compiling (DEFPARAMETER *BIND-NON-VAR-DECLARATIONS* ...)
; compiling (DEFPARAMETER *BIND-SIMPLE-VAR-DECLARATIONS* ...)
; compiling (DEFMACRO BIND ...)
; compiling (DEFUN BIND-MACRO-HELPER ...)
; compiling (DEFUN BIND-FIX-NILS ...)
; compiling (DEFUN BIND-EXPAND-DECLARATIONS ...)
; compiling (DEFUN BIND-FILTER-DECLARATIONS ...)
; compiling (DEFMACRO FLUID-BIND ...)

; /Users/gwking/darcs/metabang.bind/dev/bind.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/metatilities/dev/sbcl/generic-lisp.lisp" (written 16 NOV 2005 08:56:10 PM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (SETF (DEFAULT-INTERFACE) ...)
; compiling (DEFMETHOD IS-INTERFACE-AVAILABLE-P ...)
; compiling (DEFMETHOD QUIT-LISP* ...)
; compiling (DEFMETHOD TOTAL-BYTES-ALLOCATED* ...)
; compiling (DEFMETHOD GC-TIME* ...)
; compiling (DEFMETHOD COLLECT-GARBAGE* ...)

; /Users/gwking/darcs/metatilities/dev/sbcl/generic-lisp.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/metatilities/dev/sbcl/generic-interface-support.lisp" (written 17 NOV 2005 10:51:36 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMETHOD CHOOSE-FILE-QUESTION* ...)
; compiling (DEFMETHOD CHOOSE-NEW-FILE-QUESTION* ...)
; compiling (DEFMETHOD CHOOSE-DIRECTORY-QUESTION* ...)
; compiling (DEFMETHOD INSPECT-THING* ...)

; /Users/gwking/darcs/metatilities/dev/sbcl/generic-interface-support.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/package-additional.lisp" (written 08 NOV 2005 09:18:43 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (USE-PACKAGE "METABANG.BIND" ...)
; compiling (SHADOWING-IMPORT (QUOTE #) ...)
; compiling (SHADOWING-IMPORT (QUOTE #) ...)
; compiling (EXPORT-EXPORTED-SYMBOLS "CONTAINERS" ...)
; compiling (MAKE-LOAD-FORM* METABANG.CL-CONTAINERS:ABSTRACT-CONTAINER)
; compiling (MAKE-LOAD-FORM* METABANG.CL-CONTAINERS::BST-NODE)
; compiling (MAKE-LOAD-FORM* METABANG.CL-CONTAINERS::QUAD-TREE-NODE)

; /Users/gwking/darcs/metatilities/dev/utilities/package-additional.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/anaphoric.lisp" (written 18 NOV 2005 08:10:31 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMACRO AIF ...)
; compiling (DEFMACRO AWHEN ...)
; compiling (DEFMACRO AWHILE ...)
; compiling (DEFMACRO AAND ...)
; compiling (DEFMACRO ACOND ...)
; compiling (DEFMACRO ALAMBDA ...)
; compiling (DEFMACRO ABLOCK ...)
; compiling (DEFMACRO AIF2 ...)
; compiling (DEFMACRO AWHEN2 ...)
; compiling (DEFMACRO AWHILE2 ...)
; compiling (DEFMACRO ACOND2 ...)
; compiling (DEFMACRO APROG1 ...)
; compiling (DEFMACRO ATYPECASE ...)

; /Users/gwking/darcs/metatilities/dev/utilities/anaphoric.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/graham.lisp" (written 18 NOV 2005 08:08:14 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN MOST ...)
; compiling (DEFUN BEST ...)
; compiling (DEFUN MOSTN ...)
; compiling (DEFUN MAP0-N ...)
; compiling (DEFUN MAP1-N ...)
; compiling (DEFUN MAPA-B ...)
; compiling (DEFUN MAP-> ...)
; compiling (DEFUN MAPCARS ...)
; compiling (DEFUN FILTER-VALUES ...)
; compiling (DEFMACRO WITH-GENSYMS ...)
; compiling (DEFMACRO ALLF ...)
; compiling (DEFMACRO NILF ...)
; compiling (DEFMACRO TF ...)
; compiling (DEFMACRO TOGGLE! ...)
; compiling (DEFINE-MODIFY-MACRO TOGGLE-AUX ...)
; compiling (DEFINE-MODIFY-MACRO CONCF ...)
; compiling (DEFMACRO FN ...)
; compiling (DEFUN RBUILD ...)
; compiling (DEFUN BUILD-CALL ...)
; compiling (DEFUN BUILD-COMPOSE ...)
; compiling (DEFMACRO WITH-MATRIX ...)
; compiling (DEFMACRO WITH-ARRAY ...)
; compiling (DEFMACRO WITH-STRUCT ...)
; compiling (DEFUN MATCH ...)
; compiling (DEFUN VARSYM? ...)
; compiling (DEFUN BINDING ...)
; compiling (DEFMACRO IF-MATCH ...)
; compiling (DEFUN VARS-IN ...)

; /Users/gwking/darcs/metatilities/dev/utilities/graham.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/dates-and-times.lisp" (written 18 NOV 2005 08:09:41 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFCONSTANT +MINUTES-PER-HOUR+ ...)
; compiling (DEFCONSTANT +SECONDS-PER-MINUTE+ ...)
; compiling (DEFCONSTANT +USUAL-DAYS-PER-YEAR+ ...)
; compiling (DEFCONSTANT +SECONDS-PER-HOUR+ ...)
; compiling (DEFPARAMETER +MONTH-LIST+ ...)
; compiling (DEFPARAMETER +DAY-LIST+ ...)
; compiling (DEFPARAMETER +FLUFF-LIST+ ...)
; compiling (DEFCONSTANT +LONGER-FORMAT-INDEX+ ...)
; compiling (DEFCONSTANT +SHORTER-FORMAT-INDEX+ ...)
; compiling (DEFPARAMETER +MONTH-OUTPUT-LIST+ ...)
; compiling (DEFPARAMETER +DOW-OUTPUT-LIST ...)
; compiling (DEFPARAMETER +DAYS-PER-MONTH+ ...)
; compiling (DEFUN DAY->STRING ...)
; compiling (DEFUN MONTH->STRING ...)
; compiling (DEFUN STRING->MONTH ...)
; compiling (DEFUN PRINT-DATE ...)
; compiling (DEFUN DATE-STRING ...)
; compiling (DEFUN DATE-STRING-BRIEF ...)
; compiling (DEFUN PRINT-TIME-WITH-NO-COLONS ...)
; compiling (DEFUN PRINT-TIME ...)
; compiling (DEFUN PRINT-UNIVERSAL-TIME-WITH-NO-COLONS ...)
; compiling (DEFUN PRINT-UNIVERSAL-TIME ...)
; compiling (DEFUN TIME-STRING ...)
; compiling (DEFUN TIME-STRING-WITH-NO-COLONS ...)
; compiling (DEFUN DATE-AND-TIME-STRING ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN NTH-OK-P ...)
; compiling (DEFUN MONTH-OK-P ...)
; compiling (DEFUN DAY-OK-P ...)
; compiling (DEFUN YEARP ...)
; compiling (DEFUN INDEX-OF ...)
; compiling (DEFUN TOKEN-TYPE ...)
; compiling (DEFUN READ-TIME ...)
; compiling (DEFUN READ-DATE ...)
; compiling (DEFMACRO HANDLE-TOKEN ...)
; compiling (DEFUN PARSE-DATE-AND-TIME-STRING ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/dates-and-times.lisp
; in: DEFUN PARSE-DATE-AND-TIME-STRING
;     (ERROR "unsupported reader call")
; ==>
;   "unsupported reader call"
; 
; note: deleting unreachable code

; compiling (DEFUN PARSE-DATE-AND-TIME ...)
; compiling (DEFUN PRINT-BRIEF-UT ...)
; compiling (DEFUN PRINT-UT ...)
; compiling (DEFUN PRINT-TIME-INTERVAL ...)
; compiling (DEFUN PRINT-BRIEF-TIME-INTERVAL ...)
; compiling (DEFUN PARSE-NUMBER ...)
; compiling (DEFVAR TIME-INTERVAL-ARRAY ...)
; compiling (DEFVAR TIME-INTERVAL-UNIT-TYPES ...)
; compiling (DEFUN TIME-INTERVAL-TO-SECONDS ...)
; compiling (DEFUN PARSE-INTERVAL-OR-NEVER ...)
; compiling (DEFUN PARSE-TIME ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/dates-and-times.lisp
; in: DEFUN PARSE-TIME
;     (+ METABANG.UTILITIES:IT 4)
; 
; note: deleting unreachable code

; compiling (DEFUN INIT-TIME-INTERVAL-ARRAY ...)
; compiling (INIT-TIME-INTERVAL-ARRAY)
; compiling (DEFUN PRINT-UNIVERSAL-DATE-VERBOSE ...)
; compiling (DEFUN PRINT-DATE-VERBOSE ...)
; compiling (EVAL-ALWAYS (DEFMACRO GENERATE-TIME-PART-FUNCTION ...))
; compiling (GENERATE-TIME-PART-FUNCTION SECOND ...)
; compiling (GENERATE-TIME-PART-FUNCTION MINUTE ...)
; compiling (GENERATE-TIME-PART-FUNCTION HOUR ...)
; compiling (GENERATE-TIME-PART-FUNCTION DATE ...)
; compiling (GENERATE-TIME-PART-FUNCTION MONTH ...)
; compiling (GENERATE-TIME-PART-FUNCTION YEAR ...)
; compiling (GENERATE-TIME-PART-FUNCTION DAY-OF-WEEK ...)
; compiling (GENERATE-TIME-PART-FUNCTION DAYLIGHT-SAVINGS-TIME-P ...)
; compiling (DEFUN FORMAT-DATE ...)
; compiling (DEFUN DAYS-IN-MONTH ...)
; compiling (DEFUN LEAP-YEAR-P ...)
; compiling (DEFUN DAY-OF-YEAR ...)

; /Users/gwking/darcs/metatilities/dev/utilities/dates-and-times.fasl written
; compilation finished in 0:00:07
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/files.lisp" (written 18 NOV 2005 08:08:56 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN NICELY-FORMAT-FILENAME ...)
; compiling (DEFCONSTANT +MAC-OS-FILENAME-LIMIT+ ...)
; compiling (DEFUN FILE-TO-LIST ...)
; compiling (DEFUN UNIQUE-FILE-NAME-FROM-DATE ...)
; compiling (DEFUN PRETTY-NAMESTRING-FROM-DATE ...)
; compiling (DEFUN EOS-NAMESTRING-FROM-DATE ...)
; compiling (DEFUN SHORT-EOS-NAMESTRING-FROM-DATE ...)
; compiling (DEFUN RENAME-FILE-IF-PRESENT ...)
; compiling (DEFMETHOD UNIQUIFY-FILE-NAME ...)
; compiling (DEFMETHOD UNIQUIFY-FILE-NAME ...)
; compiling (DEFUN GOOD-FILENAME-CHAR-P ...)
; compiling (DEFUN REMOVE-ILLEGAL-FILENAME-CHARACTERS ...)
; compiling (DEFMETHOD SHORTEN-FILENAME-FOR-OS ...)
; compiling (DEFMETHOD SHORTEN-FILENAME-FOR-OS ...)
; compiling (DEFUN MAXIMUM-FILENAME-LENGTH ...)
; compiling (DEFUN MAP-FILES ...)
; compiling (DEFMETHOD MAP-FORMS-IN-FILE ...)
; compiling (DEFMETHOD MAP-FORMS-IN-FILE ...)
; compiling (DEFMETHOD MAP-FORMS-IN-FILE ...)
; compiling (DEFMETHOD MAP-LINES-IN-FILE ...)
; compiling (DEFMETHOD MAP-LINES-IN-FILE ...)
; compiling (DEFMETHOD MAP-LINES-IN-FILE ...)
; compiling (DEFMACRO MAP-LINES ...)
; compiling (DEFUN FILE-NEWER-THAN-FILE-P ...)
; compiling (DEFUN ENSURE-WILD-FILE-SPEC ...)
; compiling (DEFUN REMOVE-DEAD-VERSIONS ...)
; compiling (DEFUN FILE-PACKAGE ...)
; compiling (DEFVAR *GLU-BLAST-PATHNAME-DEFAULTS* ...)
; compiling (DEFVAR *GLU-BLAST-DEFAULT-SELECTOR* ...)
; compiling (DEFUN GLU-BLAST ...)
; compiling (DEFUN PATHNAME-IS-OLD-CVS-JUNK-P ...)
; compiling (DEFUN COPY-FILE ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/files.lisp
; in: DEFUN COPY-FILE
;     (LET ((METABANG.UTILITIES::DATA NIL) (METABANG.UTILITIES::EOF (GENSYM)))
;     (LOOP METABANG.UTILITIES::WITH
;           METABANG.UTILITIES::DATA
;           METABANG.UTILITIES::WHILE
;           (NOT (EQ (SETF METABANG.UTILITIES::DATA #) METABANG.UTILITIES::EOF))
;           DO
;           (WRITE METABANG.UTILITIES::DATA :STREAM METABANG.UTILITIES::DST)))
; 
; caught STYLE-WARNING:
;   The variable DATA is defined but never used.


; /Users/gwking/darcs/metatilities/dev/utilities/files.fasl written
; compilation finished in 0:00:05
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10002EF1}> on
   #<CL-SOURCE-FILE "files" {10002F01}>.
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/macros.lisp" (written 18 NOV 2005 08:07:01 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMACRO NYI ...); 
; caught STYLE-WARNING:
;   NYI is being redefined as a macro when it was previously assumed to be a function.

; compiling (DEFMACRO MAKE-OBSOLETE ...)
; compiling (DEFMACRO NAMED-LAMBDA ...)
; compiling (DEFMACRO DELETEF ...)
; compiling (DEFMACRO REMOVEF ...)
; compiling (DEFMACRO DOPLIST ...)
; compiling (DEFMACRO ASSERT* ...)
; compiling (DEFINE-MODIFY-MACRO MAXF ...)
; compiling (DEFINE-MODIFY-MACRO MINF ...)
; compiling (DEFINE-MODIFY-MACRO MULTF ...)
; compiling (DEFMACRO SOME* ...)
; compiling (DEFMACRO HANDLER-CASE-IF ...)
; compiling (DEFUN GENSYM* ...)
; compiling (DEFMACRO REBINDING ...)
; compiling (DEFUN FUNCTION-EXPRESSION-P ...)
; compiling (DEFUN EXTRACT-HEAD-FORM ...)
; compiling (DEFMACRO |\\| ...)
; compiling (DEFUN MAKE-HCASE-TABLE ...)
; compiling (DEFMACRO HCASE ...)
; compiling (DEFMACRO ENSURE-TYPE ...)
; compiling (DEFMACRO WITH-SLOT-BINDINGS ...)
; compiling (DEFMACRO FUNCALL-IF ...)
; compiling (DEFVAR *FILE-IF-EXISTS* ...)
; compiling (DEFVAR *FILE-PRINT-RIGHT-MARGIN* ...)
; compiling (DEFMACRO WITH-NEW-FILE ...)

; /Users/gwking/darcs/metatilities/dev/utilities/macros.fasl written
; compilation finished in 0:00:04
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40002E39}> on
   #<CL-SOURCE-FILE "macros" {40002E49}>.
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/locks.lisp" (written 21 OCT 2005 03:55:02 PM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCLASS EKSL-LOCK ...)
; compiling (DEFMETHOD REALLOCATE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFVAR *LOCKBASE* ...)
; compiling (DEFVAR *ERROR-ON-REENTRANT-REQUEST* ...)
; compiling (DEFCONSTANT +WRITE-LOCK+ ...)
; compiling (DEFCONSTANT +READ-LOCK+ ...)
; compiling (DEFUN LOOK-LOCKS ...)
; compiling (DEFUN FIND-LOCK ...)
; compiling (DEFUN GRANT-LOCK ...)
; compiling (DEFUN SERVICE-PENDING-READS ...)
; compiling (DEFUN ENQUEUE-LOCK-REQUEST ...)
; compiling (DEFUN RELEASE-EKSL-LOCK ...)
; compiling (DEFUN REQUEST-EKSL-LOCK ...)
; compiling (DEFGENERIC DESTROY-LOCK ...)
; compiling (DEFUN SAFELY-DESTROY-LOCK ...)
; compiling (DEFUN FLUSH-LOCKS ...)
; compiling (DEFUN FLUSH-LOCKS-AND-TAKE-NAMES ...)
; compiling (DEFUN ACCESS-LOCK-P ...)
; compiling (DEFMACRO WITH-EKSL-LOCK ...)
; compiling (DEFMACRO WITH-READ-ACCESS ...)
; compiling (DEFMACRO WITH-WRITE-ACCESS ...)

; /Users/gwking/darcs/metatilities/dev/utilities/locks.fasl written
; compilation finished in 0:00:04
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/sequences.lisp" (written 18 NOV 2005 08:13:22 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN REDUCE-IF ...)
; compiling (DEFUN MINIMIZE ...)
; compiling (DEFUN MAPCAN1 ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/sequences.lisp
; in: DEFUN MAPCAN1
;     (FUNCALL METABANG.UTILITIES::FUN (CAR LIST))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (FUNCALL METABANG.UTILITIES::FUN ELT)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

; compiling (DEFUN DOTTED-PAIR-P ...)
; compiling (DEFUN FLATTEN ...)
; compiling (DEFUN POWER-SET ...)
; compiling (DEFUN ALL-PAIRS ...)
; compiling (DEFUN MAP-COMBINATIONS ...)
; compiling (DEFUN COMBINATIONS ...)
; compiling (DEFUN PERMUTE ...)
; compiling (DEFUN REMOVE-MEMBERS ...)
; compiling (DEFUN TRANSPOSE ...)
; compiling (DEFUN TRANSPOSE2 ...)
; compiling (DEFUN LIST-CHOOSE-K ...)
; compiling (EXPORT (QUOTE #))
; compiling (DEFUN SAME-LENGTH-P ...)
; compiling (DEFUN LENGTH-EXACTLY-P ...)
; compiling (DEFUN PERCENT-OVERLAP ...)
; compiling (DEFUN ITERATE-OVER-INDEXES ...)

; /Users/gwking/darcs/metatilities/dev/utilities/sequences.fasl written
; compilation finished in 0:00:03
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/spy.lisp" (written 18 NOV 2005 08:04:43 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFPARAMETER *SPY-DEBUGGING* ...)
; compiling (DEFPARAMETER *SPY-OUTPUT* ...)
; compiling (DEFPARAMETER *SPY-NO-NEWLINE* ...)
; compiling (DEFPARAMETER *SPY-NO-EXPAND* ...)
; compiling (DEFUN SPY-PRIN1 ...)
; compiling (DEFUN SPY-PARSE-ARGLIST ...)
; compiling (DEFUN SPY-DO-FORM ...)
; compiling (DEFUN SPY-EXPAND-FORM ...)
; compiling (DEFMACRO SPY ...)
; compiling (DEFMACRO SPY* ...)
; compiling (DEFMACRO SPYX ...)

; /Users/gwking/darcs/metatilities/dev/utilities/spy.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/strings.lisp" (written 18 NOV 2005 08:12:39 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN STRING-BEFORE ...)
; compiling (DEFUN STRING-AFTER ...)
; compiling (DEFUN STRING-STARTS-WITH ...)
; compiling (DEFUN STRING-ENDS-WITH ...)
; compiling (DEFUN SUBSTRING ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/strings.lisp
; in: DEFUN SUBSTRING
;     (CHAR STRING METABANG.UTILITIES::R-INDEX)
; --> AREF LET* 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a STRING, not a SIMPLE-STRING.
; 
; note: unable to
;   avoid runtime dispatch on array element type
; because:
;   Upgraded element type of array is not known at compile time.

;     (CHAR-DOWNCASE METABANG.UTILITIES::C)
; 
; note: unable to
;   open code
; due to type uncertainty:
;   The first argument is a CHARACTER, not a BASE-CHAR.

; compiling (DEFUN (SETF SUBSTRING) ...)
; compiling (DEFUN STRING-CONTAINS-P ...)
; compiling (DEFUN COLLECT-TO-CHAR ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/strings.lisp
; in: DEFUN COLLECT-TO-CHAR
;     (POSITION CHAR
;             STRING
;             :START
;             METABANG.UTILITIES::START
;             :END
;             METABANG.UTILITIES::END
;             :TEST
;             #'CHAR=)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;   expand inline
; because:
;   upgraded array element type not known at compile time

; compiling (DEFUN COLLECT-TO-NOT ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/strings.lisp
; in: DEFUN COLLECT-TO-NOT
;     (POSITION CHAR
;             STRING
;             :START
;             METABANG.UTILITIES::START
;             :END
;             METABANG.UTILITIES::END
;             :TEST-NOT
;             #'CHAR=)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION SB-C::ITEM
;                             SEQUENCE
;                             SB-C::FROM-END
;                             SB-C::START
;                             SB-C::END
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY)
;                             (SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST SB-C::TEST
;                                                                     SB-C::TEST-NOT))
; 
; note: unable to
;   expand inline
; because:
;   upgraded array element type not known at compile time

; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> SB-KERNEL:%FIND-POSITION SB-KERNEL:EFFECTIVE-FIND-POSITION-TEST LET LET 
; --> COND IF COND IF COND IF PROGN 
; ==>
;   (COMPLEMENT (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:ONCE-ONLY-404))
; 
; note: unable to open code because: The function doesn't have a fixed argument count.

; compiling (DEFUN STRING->SYMBOL ...)
; compiling (DEFUN SYMBOL->STRING ...)
; compiling (DEFUN TOKENIZE-STRING ...)
; compiling (DEFUN LIST->FORMATTED-STRING ...)

; /Users/gwking/darcs/metatilities/dev/utilities/strings.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/utilities.lisp" (written 18 NOV 2005 08:02:55 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN MAPAPPEND ...); 
; caught STYLE-WARNING:
;   using deprecated EVAL-WHEN situation names LOAD

; compiling (SETF (FDEFINITION #) ...)
; compiling (DEFUN TREE-MAP ...)
; compiling (DEFUN TREE-FIND ...)
; compiling (DEFUN TREE-FIND-IF ...)
; compiling (DEFUN TREE-REMOVE-IF ...)
; compiling (DEFUN PARTITION ...)
; compiling (SETF (SYMBOL-FUNCTION #) ...)
; compiling (SETF (SYMBOL-FUNCTION #) ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN FIND-ALL ...)
; compiling (DEFUN NMERGE-LIST ...)
; compiling (DEFUN DELETE-IF! ...)
; compiling (DEFUN COMPACT-ARRAY ...)
; compiling (DEFUN CIRCULAR-LIST ...)
; compiling (DEFUN GENSYM0 ...)
; compiling (DEFUN GROUP ...)
; compiling (DEFUN MAKE-INITIALIZED-ARRAY ...)
; compiling (DEFUN FIXNUMP ...)
; compiling (DEFUN OBJECT->STRING ...)
; compiling (DEFUN FLOAT->INTEGER ...)
; compiling (DEFUN SORT-USING-LIST-ORDER ...)
; compiling (DEFUN UNUSED-VARIABLES ...)
; compiling (DEFUN LAMBDA-LIST->ARGS ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN CAR-SAFE ...)
; compiling (PROCLAIM (QUOTE #))
; compiling (DEFUN CDR-SAFE ...)
; compiling (DEFCONSTANT +VERY-SMALL-NUMBER+ ...)
; compiling (DEFUN VERY-SMALL-NUMBER-P ...)
; file: /Users/gwking/darcs/metatilities/dev/utilities/utilities.lisp
; in: DEFUN VERY-SMALL-NUMBER-P
;     (ABS NUMBER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;   The result is a (VALUES (REAL 0)
;                           &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;   The result is a (VALUES (REAL 0)
;                           &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (< (ABS NUMBER) METABANG.UTILITIES:+VERY-SMALL-NUMBER+)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SINGLE-FLOAT 0.0)
;                               (DOUBLE-FLOAT 0.0d0)
;                               (RATIONAL 0)), not a DOUBLE-FLOAT.

;     (ABS NUMBER)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0)
;                               &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0)
;                               &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (< (ABS NUMBER) METABANG.UTILITIES:+VERY-SMALL-NUMBER+)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (SINGLE-FLOAT 0.0)
;                                   (DOUBLE-FLOAT 0.0d0)
;                                   (RATIONAL 0)), not a SINGLE-FLOAT.

; compiling (DEFUN CONVERT-CLAUSES-INTO-LISTS ...)
; compiling (DEFUN CONVERT-CLAUSES-INTO-LISTS* ...)
; compiling (DEFUN CLEANUP-PARSED-PARAMETER ...)
; compiling (DEFUN FIRSTN ...)
; compiling (DEFUN CURRY ...)
; compiling (DEFINE-COMPILER-MACRO CURRY ...)
; compiling (DEFUN CURRY-AFTER ...)
; compiling (DEFUN COMPOSE ...)
; compiling (DEFUN CONJOIN ...)
; compiling (DEFINE-COMPILER-MACRO CONJOIN ...)
; compiling (DEFUN DISJOIN ...)
; compiling (DEFINE-COMPILER-MACRO DISJOIN ...)
; compiling (DEFUN ADD-CLASSES-IF-NECESSARY ...)
; compiling (DEFUN DIRECT-SUPERCLASSES-DEFCLASS* ...)
; compiling (DEFUN SUPERCLASSES-DEFCLASS* ...)
; compiling (DEFUN ADD-CLASS-IF-NECESSARY ...)
; compiling (DEFUN REMOVE-LEADING-QUOTE ...)
; compiling (DEFUN NTH-ELT-OF-CROSS-PRODUCT ...)
; compiling (DEFUN NTH-ELT-OF-CROSS-PRODUCT-AS-MULTIPLE-VALUES ...)
; compiling (DEFUN CONSTANT-EXPRESSION-P ...)
; compiling (DEFUN CONSTANT-FUNCTION-P ...)
; compiling (DEFUN MAKE-SORTER ...)
; compiling (DEFMETHOD COPY-TEMPLATE ...)
; compiling (DEFMETHOD MAKE-INSTANCE-FROM-OBJECT-INITARGS ...)
; compiling (DEFMACRO PUSH-END ...); 
; caught STYLE-WARNING:
;   PUSH-END is being redefined as a macro when it was previously assumed to be a function.


; /Users/gwking/darcs/metatilities/dev/utilities/utilities.fasl written
; compilation finished in 0:00:07
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40002DD9}> on
   #<CL-SOURCE-FILE "utilities" {40002DE9}>.
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/tcp.lisp" (written 21 OCT 2005 03:55:03 PM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (EXPORT (QUOTE #))
; compiling (DEFGENERIC OPEN-SOCKET-STREAM ...)
; compiling (DEFGENERIC CLOSE-SOCKET-STREAM ...)
; compiling (DEFMACRO WITH-OPEN-SOCKET ...)
; compiling (DEFGENERIC START-SERVER ...)

; /Users/gwking/darcs/metatilities/dev/utilities/tcp.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/searching.lisp" (written 18 NOV 2005 08:05:06 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN BINARY-SEARCH ...)
; compiling (EXPORT (QUOTE #))
; compiling (DEFUN TREE-SEARCH ...)
; compiling (DEFUN PREPEND ...)
; compiling (DEFUN DEPTH-FIRST-SEARCH ...)
; compiling (DEFUN BREADTH-FIRST-SEARCH ...)
; compiling (DEFUN MAKE-SORTER-FN ...)
; compiling (DEFUN BEST-FIRST-SEARCH ...)
; compiling (DEFUN BEAM-SEARCH ...)
; compiling (DEFUN ITER-WIDE-SEARCH ...)
; compiling (DEFUN GRAPH-SEARCH ...)
; compiling (DEFUN NEW-STATES ...)
; compiling (DEFVAR *A*-COUNT* ...)
; compiling (DEFVAR *A*-LIMIT* ...)
; compiling (DEFUN SEARCH-ALL ...)

; /Users/gwking/darcs/metatilities/dev/utilities/searching.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/metatilities/dev/utilities/views-and-windows.lisp" (written 18 NOV 2005 08:00:16 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFCLASS VIEW-REQUIRING-CLEANUP-MIXIN ...)
; compiling (DEFGENERIC CLEAN-UP-VIEW ...)
; compiling (DEFGENERIC UPDATE-DIALOG-UI ...)
; compiling (DEFCLASS* HELP-TEXT-MIXIN ...)
; compiling (DEFMETHOD HELP-SPEC ...)
; compiling (DEFCLASS* MARGINS-MIXIN ...)
; compiling (DEFMETHOD (SETF LEFT-MARGIN) ...)
; compiling (DEFMETHOD (SETF TOP-MARGIN) ...)
; compiling (DEFMETHOD (SETF RIGHT-MARGIN) ...)
; compiling (DEFMETHOD (SETF BOTTOM-MARGIN) ...)
; compiling (DEFMETHOD VIEW-X/VIEW-Y->X/Y ...)
; compiling (DEFMETHOD VIEW-SCALE ...)
; compiling (DEFGENERIC ADJUST-POINT-FOR-SCALING ...)
; compiling (DEFGENERIC VIEW-X/VIEW-Y->POINT ...)
; compiling (DEFGENERIC NOTE-VIEW-SETTINGS-CHANGED ...)
; compiling (DEFGENERIC REDRAW ...)
; compiling (DEFGENERIC DIALOG-ITEM-VALUE ...)
; compiling (DEFGENERIC (SETF DIALOG-ITEM-VALUE) ...)

; /Users/gwking/darcs/metatilities/dev/utilities/views-and-windows.fasl written
; compilation finished in 0:00:05
STYLE-WARNING: redefining TIME-SECOND in DEFUN
STYLE-WARNING: redefining TIME-MINUTE in DEFUN
STYLE-WARNING: redefining TIME-HOUR in DEFUN
STYLE-WARNING: redefining TIME-DATE in DEFUN
STYLE-WARNING: redefining TIME-MONTH in DEFUN
STYLE-WARNING: redefining TIME-YEAR in DEFUN
STYLE-WARNING: redefining TIME-DAY-OF-WEEK in DEFUN
STYLE-WARNING: redefining TIME-DAYLIGHT-SAVINGS-TIME-P in DEFUN
STYLE-WARNING: implicitly creating new generic function UNIQUIFY-FILE-NAME
STYLE-WARNING: implicitly creating new generic function SHORTEN-FILENAME-FOR-OS
STYLE-WARNING: implicitly creating new generic function MAP-FORMS-IN-FILE
STYLE-WARNING: implicitly creating new generic function MAP-LINES-IN-FILE
STYLE-WARNING: implicitly creating new generic function REALLOCATE-INSTANCE
STYLE-WARNING: implicitly creating new generic function COPY-TEMPLATE
STYLE-WARNING:
   implicitly creating new generic function MAKE-INSTANCE-FROM-OBJECT-INITARGS
STYLE-WARNING: implicitly creating new generic function HELP-SPEC
STYLE-WARNING: implicitly creating new generic function VIEW-X/VIEW-Y->X/Y
STYLE-WARNING: implicitly creating new generic function VIEW-SCALE
STYLE-WARNING: implicitly creating new generic function CROSS-PRODUCT
; compiling file "/Users/gwking/darcs/cl-graph/dev/package.lisp" (written 09 NOV 2005 05:27:46 PM):
; compiling (IN-PACKAGE COMMON-LISP-USER)
; compiling (DEFPACKAGE "CL-GRAPH" ...)

; /Users/gwking/darcs/cl-graph/dev/package.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-graph/dev/macros.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (DEFMACRO WITH-CHANGING-VERTEX ...)

; /Users/gwking/darcs/cl-graph/dev/macros.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/darcs/cl-graph/dev/graph.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (DEFCONDITION GRAPH-ERROR ...)
; compiling (DEFCONDITION EDGE-ERROR ...)
; compiling (DEFCONDITION GRAPH-VERTEX-NOT-FOUND-ERROR ...)
; compiling (DEFCONDITION GRAPH-VERTEX-NOT-FOUND-IN-EDGE-ERROR ...)
; compiling (DEFCONDITION GRAPH-EDGE-NOT-FOUND-ERROR ...)
; compiling (DEFCLASS* BASIC-VERTEX ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFCLASS* BASIC-EDGE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFCLASS* DIRECTED-EDGE-MIXIN ...)
; compiling (DEFCLASS* WEIGHTED-EDGE-MIXIN ...)
; compiling (DEFMETHOD WEIGHT ...)
; compiling (DEFCLASS* BASIC-GRAPH ...)
; compiling (DEFGENERIC MAKE-VERTEX-CONTAINER ...)
; compiling (DEFGENERIC MAKE-EDGE-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFMETHOD MAKE-VERTEX-FOR-GRAPH ...)
; compiling (DEFMETHOD MAKE-EDGE-FOR-GRAPH ...)
; compiling (DEFGENERIC MAKE-GRAPH ...)
; compiling (DEFMETHOD MAKE-GRAPH ...)
; compiling (DEFMETHOD MAKE-GRAPH ...)
; compiling (DEFGENERIC MAKE-EDGE-FOR-GRAPH ...)
; compiling (DEFGENERIC ADD-EDGE ...)
; compiling (DEFGENERIC ADD-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFGENERIC DELETE-EDGE ...)
; compiling (DEFGENERIC DELETE-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFGENERIC ADD-VERTEX ...)
; compiling (DEFGENERIC DELETE-VERTEX ...)
; compiling (DEFGENERIC FIND-VERTEX ...)
; compiling (DEFGENERIC SEARCH-FOR-VERTEX ...)
; compiling (DEFGENERIC FIND-EDGE ...)
; compiling (DEFGENERIC FIND-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFGENERIC SOURCE-VERTEX ...)
; compiling (DEFGENERIC TARGET-VERTEX ...)
; compiling (DEFGENERIC ITERATE-EDGES ...)
; compiling (DEFGENERIC ITERATE-SOURCE-EDGES ...)
; compiling (DEFGENERIC ITERATE-TARGET-EDGES ...)
; compiling (DEFGENERIC ITERATE-CHILDREN ...)
; compiling (DEFGENERIC HAS-CHILDREN-P ...)
; compiling (DEFGENERIC HAS-PARENT-P ...)
; compiling (DEFGENERIC ITERATE-PARENTS ...)
; compiling (DEFGENERIC ITERATE-NEIGHBORS ...)
; compiling (DEFGENERIC RENUMBER-VERTEXES ...)
; compiling (DEFGENERIC RENUMBER-EDGES ...)
; compiling (DEFGENERIC GENERATE-DIRECTED-FREE-TREE ...)
; compiling (DEFGENERIC IN-UNDIRECTED-CYCLE-P ...)
; compiling (DEFGENERIC UNDIRECTED-EDGE-P ...)
; compiling (DEFGENERIC DIRECTED-EDGE-P ...)
; compiling (DEFGENERIC TAGGED-EDGE-P ...)
; compiling (DEFGENERIC UNTAGGED-EDGE-P ...)
; compiling (DEFMETHOD UNDIRECTED-EDGE-P ...)
; compiling (DEFMETHOD DIRECTED-EDGE-P ...)
; compiling (DEFMETHOD TAGGED-EDGE-P ...)
; compiling (DEFMETHOD UNTAGGED-EDGE-P ...)
; compiling (DEFMETHOD TAG-ALL-EDGES ...)
; compiling (DEFMETHOD TAG-ALL-EDGES ...)
; compiling (DEFMETHOD UNTAG-ALL-EDGES ...)
; compiling (DEFMETHOD UNTAG-ALL-EDGES ...)
; compiling (DEFMETHOD UNTAG-EDGES ...)
; compiling (DEFMETHOD TAG-EDGES ...)
; compiling (DEFMETHOD (SETF ELEMENT) ...)
; compiling (DEFMETHOD ADD-VERTEX ...)
; compiling (DEFMETHOD REPLACE-VERTEX ...)
; compiling (DEFMETHOD ADD-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFMETHOD ADD-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFMETHOD ADD-EDGE-TO-VERTEX ...)
; compiling (DEFMETHOD FIND-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFMETHOD DELETE-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFMETHOD DELETE-EDGE ...)
; compiling (DEFMETHOD DELETE-VERTEX ...)
; compiling (DEFMETHOD DELETE-VERTEX ...)
; compiling (DEFMETHOD DELETE-VERTEX ...)
; compiling (DEFMETHOD INSERT-ITEM ...)
; compiling (DEFMETHOD SOURCE-EDGES ...)
; compiling (DEFMETHOD TARGET-EDGES ...)
; compiling (DEFMETHOD CHILD-VERTEXES ...)
; compiling (DEFMETHOD PARENT-VERTEXES ...)
; compiling (DEFMETHOD NEIGHBOR-VERTEXES ...)
; compiling (DEFUN ADJACENTP ...)
; compiling (DEFMETHOD NUMBER-OF-NEIGHBORS ...)
; compiling (DEFMETHOD IN-CYCLE-P ...)
; compiling (DEFMETHOD RENUMBER-VERTEXES ...)
; compiling (DEFMETHOD RENUMBER-EDGES ...)
; compiling (DEPRECATED (DEFMETHOD CONTAINER->LIST ...))
; compiling (DEFMETHOD ADD-VERTEX ...)
; compiling (DEFMETHOD ADD-EDGE ...)
; compiling (DEFMETHOD FIND-VERTEX ...)
; compiling (DEFMETHOD FIND-VERTEX ...)
; compiling (DEFMETHOD SEARCH-FOR-VERTEX ...)
; compiling (DEFMETHOD SEARCH-FOR-VERTEX ...)
; compiling (DEFMETHOD SEARCH-FOR-VERTEX ...)
; compiling (DEFMETHOD ITERATE-ELEMENTS ...)
; compiling (DEFMETHOD ITERATE-NODES ...)
; compiling (DEFMETHOD ITERATE-VERTEXES ...)
; compiling (DEFMETHOD ITERATE-VERTEXES ...)
; compiling (DEFMETHOD SIZE ...)
; compiling (DEFMETHOD EDGES ...)
; compiling (DEFMETHOD EDGES ...)
; compiling (DEPRECATED "Use size instead" ...)
; compiling (DEFMETHOD VERTEXES ...)
; compiling (DEFMETHOD SOURCE-EDGE-COUNT ...)
; compiling (DEFMETHOD TARGET-EDGE-COUNT ...)
; compiling (DEFMETHOD GRAPH-ROOTS ...)
; compiling (DEFMETHOD ROOTP ...)
; compiling (DEFMETHOD FIND-VERTEX-IF ...)
; compiling (DEFMETHOD FIND-VERTEX-IF ...)
; compiling (DEFMETHOD FIND-EDGE-IF ...)
; compiling (DEFMETHOD FIND-EDGES-IF ...)
; compiling (DEFMETHOD FIND-VERTEXES-IF ...)
; compiling (DEFMETHOD EMPTY! ...)
; compiling (DEFUN NEIGHBORS-TO-CHILDREN ...)
; compiling (DEFMETHOD GENERATE-DIRECTED-FREE-TREE ...)
; compiling (DEFMETHOD FORCE-UNDIRECTED ...)
; compiling (DEFMETHOD TRAVERSE-ELEMENTS ...)
; compiling (DEFMETHOD TRAVERSE-ELEMENTS-HELPER ...)
; compiling (DEFMETHOD TRAVERSE-ELEMENTS-HELPER ...)
; compiling (DEFMETHOD IN-CYCLE-P ...)
; compiling (DEFMETHOD IN-UNDIRECTED-CYCLE-P ...)
; compiling (DEFMETHOD ANY-UNDIRECTED-CYCLE-P ...)
; compiling (DEFUN REMOVE-LIST ...)
; compiling (DEFUN GET-NODELIST-RELATIVES ...)
; compiling (DEFUN GET-TRANSITIVE-CLOSURE ...)
; compiling (DEFMETHOD COMPLETE-LINKS ...)
; compiling (DEFGENERIC MAKE-FILTERED-GRAPH ...)
; compiling (DEFMETHOD MAKE-FILTERED-GRAPH ...)
; compiling (DEFMETHOD SUBGRAPH-CONTAINING ...)
; compiling (DEFMETHOD EDGE-COUNT ...)
; compiling (DEFMETHOD EDGE-COUNT ...)
; compiling (DEFMETHOD TOPOLOGICAL-SORT ...)
; compiling (DEFMETHOD ASSIGN-LEVEL ...)
; compiling (DEFMETHOD ASSIGN-LEVEL ...)
; compiling (DEFMETHOD DEPTH ...)
; compiling (DEFUN MAP-PATHS ...)
; compiling (DEFUN MAP-SHORTEST-PATHS ...)
; compiling (DEFUN APPEND-UNIQUE ...)

; /Users/gwking/darcs/cl-graph/dev/graph.fasl written
; compilation finished in 0:00:37
; compiling file "/Users/gwking/darcs/cl-graph/dev/graph-container.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFCLASS* GRAPH-CONTAINER ...)
; compiling (DEFCLASS* GRAPH-CONTAINER-EDGE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFCLASS* WEIGHTED-EDGE ...)
; compiling (DEFCLASS* GRAPH-CONTAINER-VERTEX ...)
; compiling (DEFMETHOD MAKE-VERTEX-EDGES-CONTAINER ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD MAKE-VERTEX-CONTAINER ...)
; compiling (DEFMETHOD MAKE-EDGE-CONTAINER ...)
; compiling (DEFCLASS* GRAPH-CONTAINER-DIRECTED-EDGE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD SOURCE-VERTEX ...)
; compiling (DEFMETHOD TARGET-VERTEX ...)
; compiling (DEFMETHOD OTHER-VERTEX ...)
; compiling (DEFMETHOD OTHER-VERTEX ...)
; compiling (DEFMETHOD ADD-EDGE ...)
; compiling (DEFMETHOD ADD-EDGE-TO-VERTEX ...)
; compiling (DEFMETHOD MAKE-NODE-FOR-CONTAINER ...)
; compiling (DEFMETHOD FIND-EDGE-BETWEEN-VERTEXES ...)
; compiling (DEFMETHOD FIND-EDGE-BETWEEN-VERTEXES-IF ...)
; compiling (DEFMETHOD FIND-EDGE-BETWEEN-VERTEXES-IF ...)
; compiling (DEFMETHOD FIND-EDGE ...)
; compiling (DEFMETHOD DELETE-EDGE ...)
; compiling (DEFMETHOD ITERATE-EDGES ...)
; compiling (DEFMETHOD ITERATE-EDGES ...)
; compiling (DEFMETHOD ITERATE-SOURCE-EDGES ...)
; compiling (DEFMETHOD ITERATE-TARGET-EDGES ...)
; compiling (DEFMETHOD ITERATE-CHILDREN ...)
; compiling (DEFMETHOD ITERATE-PARENTS ...)
; compiling (DEFMETHOD ITERATE-NEIGHBORS ...)
; compiling (DEFMETHOD VERTEXES ...)
; compiling (DEFMETHOD HAS-CHILDREN-P ...)
; compiling (DEFMETHOD HAS-PARENT-P ...)
; compiling (DEFMETHOD VERTICES-SHARE-EDGE-P ...)

; /Users/gwking/darcs/cl-graph/dev/graph-container.fasl written
; compilation finished in 0:00:12
; compiling file "/Users/gwking/darcs/cl-graph/dev/graph-matrix.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (DEFCLASS* GRAPH-MATRIX ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD MAKE-VERTEX-CONTAINER ...)
; compiling (DEFMETHOD MAKE-EDGE-CONTAINER ...)
; compiling (DEFCLASS* GRAPH-MATRIX-EDGE ...)
; compiling (DEFCLASS* GRAPH-MATRIX-VERTEX ...)

; /Users/gwking/darcs/cl-graph/dev/graph-matrix.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/darcs/cl-graph/dev/graph-metrics.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (EXPORT (QUOTE #))
; compiling (DEFUN VERTEX-DEGREE-COUNTS ...)
; compiling (DEFUN AVERAGE-VERTEX-DEGREE ...)
; compiling (DEFUN VERTEX-DEGREE ...)
; compiling (DEFUN %VERTEX-DEGREE ...)
; compiling (DEFUN VERTEX-DEGREE-SUMMARY ...)
; compiling (DEFUN AVERAGE-VERTEX-CLUSTERING-COEFFICIENT ...)
; compiling (DEFUN VERTEX-CLUSTERING-COEFFICIENT ...)
; compiling (DEFUN VERTEX-TRIANGLE-COUNT ...)
; compiling (DEFUN ROW-SUMS ...)
; compiling (DEFUN COLUMN-SUMS ...)
; compiling (DEFGENERIC ASSORTATIVITY-COEFFICIENT ...)
; compiling (DEFMETHOD ASSORTATIVITY-COEFFICIENT ...)
; compiling (DEFMETHOD GRAPH-EDGE-MIXTURE-MATRIX ...)
; compiling (DEFMETHOD GRAPH-MIXING-MATRIX ...)
; compiling (DEFMETHOD UNIQUE-ELEMENTS ...)
; compiling (DEFMETHOD UNIQUE-ELEMENTS ...)
; compiling (DEFMETHOD UNIQUE-NODES ...)
; compiling (DEFMETHOD UNIQUE-NODES ...)
; compiling (DEFUN %UNIQUE-ELEMENTS ...)

; /Users/gwking/darcs/cl-graph/dev/graph-metrics.fasl written
; compilation finished in 0:00:06
; compiling file "/Users/gwking/darcs/cl-graph/dev/graph-algorithms.lisp" (written 21 OCT 2005 03:54:54 PM):
; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (DEFSTRUCT (VERTEX-DATUM # ...) ...)
; compiling (DEFMETHOD INITIALIZE-VERTEX-DATA ...)
; compiling (DEFMETHOD BREADTH-FIRST-VISITOR ...)
; compiling (DEFMETHOD BREADTH-FIRST-VISITOR ...)
; compiling (DEFMETHOD BREADTH-FIRST-SEARCH-GRAPH ...)
; compiling (DEFMETHOD BREADTH-FIRST-SEARCH-GRAPH ...)
; compiling (DEFMETHOD CONNECTED-COMPONENTS ...)
; compiling (DEFMETHOD FIND-CONNECTED-COMPONENTS ...)
; compiling (DEFMETHOD MST-FIND-SET ...)
; compiling (DEFMETHOD MST-MAKE-SET ...)
; compiling (DEFMETHOD MST-TREE-UNION ...)
; compiling (DEFMETHOD MST-LINK ...)
; compiling (DEFMETHOD ADD-EDGES-TO-GRAPH ...)
; compiling (DEFMETHOD MAKE-GRAPH-FROM-VERTEXES ...)
; compiling (DEFMETHOD EDGE-LESSP-BY-WEIGHT ...)
; compiling (DEFMETHOD MINIMUM-SPANNING-TREE ...)
; compiling (DEFMETHOD CONNECTED-GRAPH-P ...)
; compiling (DEFPARAMETER *DEPTH-FIRST-SEARCH-TIMER* ...)
; compiling (DEFMETHOD EDGE-LESSP-BY-DIRECTION ...)
; compiling (DEFMETHOD OUT-EDGE-FOR-VERTEX-P ...)
; compiling (DEFMETHOD DFS ...)
; compiling (DEFMETHOD DFS ...)
; compiling (DEFMETHOD DFS-VISIT ...)
; compiling (DEFMETHOD DFS-TREE-EDGE-P ...)
; compiling (DEFMETHOD DFS-BACK-EDGE-P ...)
; compiling (DEFMETHOD DFS-FORWARD-EDGE-P ...)
; compiling (DEFMETHOD DFS-CROSS-EDGE-P ...)
; compiling (DEFMETHOD DFS-EDGE-TYPE ...)
; compiling (DEFMETHOD MAP-OVER-ALL-COMBINATIONS-OF-K-VERTEXES ...)
; compiling (DEFMETHOD MAP-OVER-ALL-COMBINATIONS-OF-K-EDGES ...)
; compiling (DEFMETHOD MAP-OVER-ALL-COMBINATIONS-OF-K-EDGES ...)

; /Users/gwking/darcs/cl-graph/dev/graph-algorithms.fasl written
; compilation finished in 0:00:11
; compiling file "/Users/gwking/darcs/cl-graph/dev/graphviz-support.lisp" (written 09 NOV 2005 04:12:56 PM):
; 
; caught STYLE-WARNING:
;   Character decoding error in a #|-comment at position 633 reading source file #<FD-STREAM for "file /Users/gwking/darcs/cl-graph/dev/graphviz-support.lisp" {418700F1}>, resyncing.

; 
; caught STYLE-WARNING:
;   Character decoding error in a #|-comment at position 635 reading source file #<FD-STREAM for "file /Users/gwking/darcs/cl-graph/dev/graphviz-support.lisp" {418700F1}>, resyncing.

; compiling (IN-PACKAGE METABANG.GRAPH)
; compiling (DEFMETHOD GRAPH->DOT ...)
; compiling (DEFMETHOD GRAPH->DOT ...)
; compiling (DEFMETHOD GRAPH->DOT ...)
; compiling (DEFMETHOD GRAPH->DOT ...)
; compiling (DEFMETHOD GRAPH->DOT ...)
; compiling (DEFMETHOD GRAPH->DOT-PROPERTIES ...)
; compiling (DEFMETHOD VERTEX->DOT ...)
; compiling (DEFMETHOD EDGE->DOT ...)

; /Users/gwking/darcs/cl-graph/dev/graphviz-support.fasl written
; compilation finished in 0:00:04
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10002E89}> on
   #<CL-SOURCE-FILE "graphviz-support" {10002E99}>.
STYLE-WARNING: redefining MAKE-LOAD-FORM (BASIC-VERTEX) in DEFMETHOD
STYLE-WARNING: redefining MAKE-LOAD-FORM (BASIC-EDGE) in DEFMETHOD
STYLE-WARNING: redefining MAKE-LOAD-FORM (BASIC-GRAPH) in DEFMETHOD
STYLE-WARNING: implicitly creating new generic function MAKE-VERTEX-FOR-GRAPH
STYLE-WARNING: implicitly creating new generic function MAKE-EDGE-FOR-GRAPH
STYLE-WARNING: redefining MAKE-EDGE-FOR-GRAPH in DEFGENERIC
STYLE-WARNING: redefining ITERATE-CHILDREN in DEFGENERIC
STYLE-WARNING: implicitly creating new generic function TAG-ALL-EDGES
STYLE-WARNING: implicitly creating new generic function UNTAG-ALL-EDGES
STYLE-WARNING: implicitly creating new generic function UNTAG-EDGES
STYLE-WARNING: implicitly creating new generic function TAG-EDGES
STYLE-WARNING: implicitly creating new generic function REPLACE-VERTEX
STYLE-WARNING: implicitly creating new generic function ADD-EDGE-TO-VERTEX
STYLE-WARNING: implicitly creating new generic function SOURCE-EDGES
STYLE-WARNING: implicitly creating new generic function TARGET-EDGES
STYLE-WARNING: implicitly creating new generic function CHILD-VERTEXES
STYLE-WARNING: implicitly creating new generic function PARENT-VERTEXES
STYLE-WARNING: implicitly creating new generic function NEIGHBOR-VERTEXES
STYLE-WARNING: implicitly creating new generic function NUMBER-OF-NEIGHBORS
STYLE-WARNING: implicitly creating new generic function IN-CYCLE-P
STYLE-WARNING: redefining SEARCH-FOR-VERTEX (BASIC-GRAPH T) in DEFMETHOD
STYLE-WARNING: implicitly creating new generic function ITERATE-VERTEXES
STYLE-WARNING: implicitly creating new generic function EDGES
STYLE-WARNING: implicitly creating new generic function VERTEX-COUNT
STYLE-WARNING: implicitly creating new generic function VERTEXES
STYLE-WARNING: implicitly creating new generic function SOURCE-EDGE-COUNT
STYLE-WARNING: implicitly creating new generic function TARGET-EDGE-COUNT
STYLE-WARNING: implicitly creating new generic function GRAPH-ROOTS
STYLE-WARNING: implicitly creating new generic function ROOTP
STYLE-WARNING: implicitly creating new generic function FIND-VERTEX-IF
STYLE-WARNING: implicitly creating new generic function FIND-EDGE-IF
STYLE-WARNING: implicitly creating new generic function FIND-EDGES-IF
STYLE-WARNING: implicitly creating new generic function FIND-VERTEXES-IF
STYLE-WARNING: implicitly creating new generic function FORCE-UNDIRECTED
STYLE-WARNING: implicitly creating new generic function TRAVERSE-ELEMENTS
STYLE-WARNING: implicitly creating new generic function TRAVERSE-ELEMENTS-HELPER
STYLE-WARNING: implicitly creating new generic function ANY-UNDIRECTED-CYCLE-P
STYLE-WARNING: implicitly creating new generic function COMPLETE-LINKS
STYLE-WARNING: implicitly creating new generic function SUBGRAPH-CONTAINING
STYLE-WARNING: implicitly creating new generic function EDGE-COUNT
STYLE-WARNING: implicitly creating new generic function TOPOLOGICAL-SORT
STYLE-WARNING: implicitly creating new generic function ASSIGN-LEVEL
STYLE-WARNING: implicitly creating new generic function DEPTH
STYLE-WARNING:
   implicitly creating new generic function MAKE-VERTEX-EDGES-CONTAINER
STYLE-WARNING: implicitly creating new generic function OTHER-VERTEX
STYLE-WARNING:
   implicitly creating new generic function FIND-EDGE-BETWEEN-VERTEXES-IF
STYLE-WARNING: implicitly creating new generic function VERTICES-SHARE-EDGE-P
STYLE-WARNING:
   implicitly creating new generic function GRAPH-EDGE-MIXTURE-MATRIX
STYLE-WARNING: implicitly creating new generic function GRAPH-MIXING-MATRIX
STYLE-WARNING: implicitly creating new generic function UNIQUE-ELEMENTS
STYLE-WARNING: implicitly creating new generic function UNIQUE-NODES
STYLE-WARNING: implicitly creating new generic function INITIALIZE-VERTEX-DATA
STYLE-WARNING: implicitly creating new generic function BREADTH-FIRST-VISITOR
STYLE-WARNING:
   implicitly creating new generic function BREADTH-FIRST-SEARCH-GRAPH
STYLE-WARNING: implicitly creating new generic function CONNECTED-COMPONENTS
STYLE-WARNING:
   implicitly creating new generic function FIND-CONNECTED-COMPONENTS
STYLE-WARNING: implicitly creating new generic function MST-FIND-SET
STYLE-WARNING: implicitly creating new generic function MST-MAKE-SET
STYLE-WARNING: implicitly creating new generic function MST-TREE-UNION
STYLE-WARNING: implicitly creating new generic function MST-LINK
STYLE-WARNING: implicitly creating new generic function ADD-EDGES-TO-GRAPH
STYLE-WARNING: implicitly creating new generic function MAKE-GRAPH-FROM-VERTEXES
STYLE-WARNING: implicitly creating new generic function EDGE-LESSP-BY-WEIGHT
STYLE-WARNING: implicitly creating new generic function MINIMUM-SPANNING-TREE
STYLE-WARNING: implicitly creating new generic function CONNECTED-GRAPH-P
STYLE-WARNING: implicitly creating new generic function EDGE-LESSP-BY-DIRECTION
STYLE-WARNING: implicitly creating new generic function OUT-EDGE-FOR-VERTEX-P
STYLE-WARNING: implicitly creating new generic function DFS
STYLE-WARNING: implicitly creating new generic function DFS-VISIT
STYLE-WARNING: implicitly creating new generic function DFS-TREE-EDGE-P
STYLE-WARNING: implicitly creating new generic function DFS-BACK-EDGE-P
STYLE-WARNING: implicitly creating new generic function DFS-FORWARD-EDGE-P
STYLE-WARNING: implicitly creating new generic function DFS-CROSS-EDGE-P
STYLE-WARNING: implicitly creating new generic function DFS-EDGE-TYPE
STYLE-WARNING:
   implicitly creating new generic function MAP-OVER-ALL-COMBINATIONS-OF-K-VERTEXES
STYLE-WARNING:
   implicitly creating new generic function MAP-OVER-ALL-COMBINATIONS-OF-K-EDGES
STYLE-WARNING: implicitly creating new generic function GRAPH->DOT
STYLE-WARNING: implicitly creating new generic function GRAPH->DOT-PROPERTIES
STYLE-WARNING: implicitly creating new generic function VERTEX->DOT
STYLE-WARNING: implicitly creating new generic function EDGE->DOT

; file: /Users/gwking/darcs/metatilities/dev/utilities/locks.lisp
; in: DEFUN METABANG.UTILITIES::FIND-LOCK
;     (METABANG.UTILITIES::ALLOCATE-EKSL-LOCK :NAME METABANG.UTILITIES::LOCK-NAME)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES::ALLOCATE-EKSL-LOCK


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-VERBOSE-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates almost every statistic of a linear regression: the slope and
; intercept of the line, the standard error on each, the correlation coefficient,
; the coefficient of determination, also known as r-square, and an ANOVA table as
; described in the manual.
; 
; If you don't need all this information, consider using the ``-brief'' or
; ``-minimal'' functions, which do less computation.
; 
; This function differs from `linear-regression-verbose' in that it takes summary
; variables: `x' and `y' are the sums of the independent variable and dependent
; variables, respectively; `x2' and `y2' are the sums of the squares of the
; independent variable and dependent variables, respectively; and `xy' is the sum
; of the products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE
;      (VALUES CL-MATHSTATS::SLOPE
;              CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::DETERMINATION
;              CL-MATHSTATS::CORRELATION
;              CL-MATHSTATS::STD-ERR-SLOPE
;              CL-MATHSTATS::STD-ERR-INTERCEPT
;              CL-MATHSTATS::ANOVA-TABLE))
;     (LET ((CL-MATHSTATS::NSSX (- # #))
;           (CL-MATHSTATS::NSSY (- # #))
;           (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (OR (ZEROP CL-MATHSTATS::NSSX) (ZEROP CL-MATHSTATS::NSSY))
;         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #)
;              (CL-MATHSTATS::INTERCEPT #)
;              (CL-MATHSTATS::NSSR #)
;              (CL-MATHSTATS::NSSE #)
;              (CL-MATHSTATS::DETERMINATION #)
;              (CL-MATHSTATS::CORRELATION #)
;              (CL-MATHSTATS::DOF #)
;              (CL-MATHSTATS::STD-ERR-SLOPE #)
;              (CL-MATHSTATS::STD-ERR-INTERCEPT NIL)
;              (CL-MATHSTATS::F #)
;              (CL-MATHSTATS::P-VALUE #)
;              (CL-MATHSTATS::SSR #)
;              ...)
;         (VALUES CL-MATHSTATS::SLOPE
;                 CL-MATHSTATS::INTERCEPT
;                 CL-MATHSTATS::DETERMINATION
;                 CL-MATHSTATS::CORRELATION
;                 CL-MATHSTATS::STD-ERR-SLOPE
;                 CL-MATHSTATS::STD-ERR-INTERCEPT
;                 CL-MATHSTATS::ANOVA-TABLE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G247 'CL-MATHSTATS::ANOVA-TABLE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::ANOVA-TABLE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G247 'CL-MATHSTATS::ANOVA-TABLE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::ANOVA-TABLE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE
;                                   CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::DETERMINATION
;                                   CL-MATHSTATS::CORRELATION
;                                   CL-MATHSTATS::STD-ERR-SLOPE
;                                   CL-MATHSTATS::STD-ERR-INTERCEPT
;                                   CL-MATHSTATS::ANOVA-TABLE))
;                          (BLOCK
;                              CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #)
;                                  (CL-MATHSTATS::NSSY #)
;                                  (CL-MATHSTATS::NSSXY #))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# # # # # # # # # # # # ...)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT
;                                        CL-MATHSTATS::DETERMINATION
;                                        CL-MATHSTATS::CORRELATION
;                                        CL-MATHSTATS::STD-ERR-SLOPE
;                                        CL-MATHSTATS::STD-ERR-INTERCEPT
;                                        CL-MATHSTATS::ANOVA-TABLE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::ANOVA-TABLE

; 
; caught STYLE-WARNING:
;   1 more use of undefined type CL-MATHSTATS::ANOVA-TABLE


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G573 'CL-MATHSTATS::BETAS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::BETAS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G573 'CL-MATHSTATS::BETAS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::BETAS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::BETAS

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::BETAS


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS (CL-MATHSTATS::CONTINGENCY-TABLE)
;     "Calculates the chi-square statistic and corresponding p-value for the given
; contingency table.  The result says whether the row factor is independent of the
; column factor.  Does not apply Yate's correction."
;     (DECLARE (VALUES CL-MATHSTATS::CHI-SQUARE CL-MATHSTATS::P-VALUE))
;     (CHECK-TYPE CL-MATHSTATS::CONTINGENCY-TABLE (ARRAY * 2))
;     (DESTRUCTURING-BIND
;         (CL-MATHSTATS::ROWS CL-MATHSTATS::COLS)
;         (ARRAY-DIMENSIONS CL-MATHSTATS::CONTINGENCY-TABLE)
;       (MACROLET ((CL-MATHSTATS::ROW-SUM #
;                    `#)
;                  (CL-MATHSTATS::COL-SUM #
;                    `#))
;         (LET (# #)
;           (DOTIMES # #)
;           (VALUES CL-MATHSTATS::CHI-2 #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2352 'CL-MATHSTATS::CHI-SQUARE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI-SQUARE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS
;                          (CL-MATHSTATS::CONTINGENCY-TABLE)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::P-VALUE))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS
;                            (CHECK-TYPE CL-MATHSTATS::CONTINGENCY-TABLE
;                                        (ARRAY * 2))
;                            (DESTRUCTURING-BIND
;                                (CL-MATHSTATS::ROWS CL-MATHSTATS::COLS)
;                                (ARRAY-DIMENSIONS
;                                 CL-MATHSTATS::CONTINGENCY-TABLE)
;                              (MACROLET (# #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI-SQUARE

; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2 (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables with only two values; the function
; will construct a 2x2 contingency table by counting the number of occurrences of
; each combination of the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTINGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (UNLESS (EQUAL '(2 2) (ARRAY-DIMENSIONS CL-MATHSTATS::2X2-TABLE))
;         (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;       (LET ((CL-MATHSTATS::A #)
;             (CL-MATHSTATS::B #)
;             (CL-MATHSTATS::C #)
;             (CL-MATHSTATS::D #))
;         (MULTIPLE-VALUE-CALL #'VALUES
;           (CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS CL-MATHSTATS::A
;                                                CL-MATHSTATS::B
;                                                CL-MATHSTATS::C
;                                                CL-MATHSTATS::D)
;           CL-MATHSTATS::2X2-TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::CONTINGENCY-TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2
;                            (MULTIPLE-VALUE-BIND
;                                (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                                         CL-MATHSTATS::V2-VALUES)
;                                (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                                 CL-MATHSTATS::V1
;                                 CL-MATHSTATS::V2)
;                              (UNLESS (EQUAL '# #)
;                                (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;                              (LET (# # # #)
;                                (MULTIPLE-VALUE-CALL #'VALUES
;                                  #
;                                  CL-MATHSTATS::2X2-TABLE
;                                  CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI-SQUARE

; 
; caught STYLE-WARNING:
;   4 more uses of undefined type CL-MATHSTATS::CHI-SQUARE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;          (CL-MATHSTATS::A CL-MATHSTATS::B CL-MATHSTATS::C CL-MATHSTATS::D
;           &OPTIONAL (CL-MATHSTATS::YATES T))
;     "Runs a chi-square test for association on a simple 2 x 2 table.  If `yates'
; is nil, the correction for continuity is not done; default is t.
; 
; Returns the chi-square statistic and the significance of the value."
;     (DECLARE (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))
;     (CHECK-TYPE CL-MATHSTATS::A INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::B INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::C INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::D INTEGER)
;     (LET ((CL-MATHSTATS::N
;            (+ CL-MATHSTATS::A CL-MATHSTATS::B CL-MATHSTATS::C CL-MATHSTATS::D))
;           (CL-MATHSTATS::DENOM (* # # # #))
;           (CL-MATHSTATS::NUMER (- # #)))
;       (WHEN CL-MATHSTATS::YATES (SETF CL-MATHSTATS::NUMER (- # #)))
;       (SETF CL-MATHSTATS::NUMER
;               (* CL-MATHSTATS::N (CL-MATHSTATS:SQUARE CL-MATHSTATS::NUMER)))
;       (LET* ((CL-MATHSTATS::CHI2 #) (CL-MATHSTATS::P-VALUE #))
;         (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2279 'CL-MATHSTATS::CHI2)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI2

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2279 'CL-MATHSTATS::CHI2)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI2

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;                          (CL-MATHSTATS::A CL-MATHSTATS::B
;                                           CL-MATHSTATS::C
;                                           CL-MATHSTATS::D
;                                           &OPTIONAL
;                                           (CL-MATHSTATS::YATES T))
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;                            (CHECK-TYPE CL-MATHSTATS::A INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::B INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::C INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::D INTEGER)
;                            (LET ((CL-MATHSTATS::N #)
;                                  (CL-MATHSTATS::DENOM #)
;                                  (CL-MATHSTATS::NUMER #))
;                              (WHEN CL-MATHSTATS::YATES
;                                (SETF CL-MATHSTATS::NUMER #))
;                              (SETF CL-MATHSTATS::NUMER (* CL-MATHSTATS::N #))
;                              (LET* (# #)
;                                (VALUES CL-MATHSTATS::CHI2
;                                        CL-MATHSTATS::P-VALUE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CHI2

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::CHI2


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G570 'CL-MATHSTATS::COEFFICIENTS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COEFFICIENTS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G570 'CL-MATHSTATS::COEFFICIENTS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COEFFICIENTS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COEFFICIENTS

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::COEFFICIENTS


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G582 'CL-MATHSTATS::COMPATIBILITY-VALUE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COMPATIBILITY-VALUE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G582 'CL-MATHSTATS::COMPATIBILITY-VALUE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COMPATIBILITY-VALUE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::COMPATIBILITY-VALUE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::COMPATIBILITY-VALUE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::CHI-SQUARE-RXC
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-RXC (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables; the function will construct a
; contingency table by counting the number of occurrences of each combination of
; the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTIGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (CHECK-TYPE CL-MATHSTATS::V1 SEQUENCE)
;     (CHECK-TYPE CL-MATHSTATS::V2 SEQUENCE)
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::TABLE CL-MATHSTATS::V1-VALUES CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (MULTIPLE-VALUE-CALL #'VALUES
;         (CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS CL-MATHSTATS::TABLE)
;         (CL-MATHSTATS::G-TEST CL-MATHSTATS::TABLE NIL NIL)
;         CL-MATHSTATS::TABLE
;         CL-MATHSTATS::V1-VALUES
;         CL-MATHSTATS::V2-VALUES)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-RXC
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::CONTIGENCY-TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-RXC
;                            (CHECK-TYPE CL-MATHSTATS::V1 SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::V2 SEQUENCE)
;                            (MULTIPLE-VALUE-BIND
;                                (CL-MATHSTATS::TABLE CL-MATHSTATS::V1-VALUES
;                                                     CL-MATHSTATS::V2-VALUES)
;                                (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                                 CL-MATHSTATS::V1
;                                 CL-MATHSTATS::V2)
;                              (MULTIPLE-VALUE-CALL #'VALUES
;                                (CL-MATHSTATS::CHI-SQUARE-RXC-COUNTS
;                                 CL-MATHSTATS::TABLE)
;                                (CL-MATHSTATS::G-TEST CL-MATHSTATS::TABLE
;                                                      NIL
;                                                      NIL)
;                                CL-MATHSTATS::TABLE
;                                CL-MATHSTATS::V1-VALUES
;                                CL-MATHSTATS::V2-VALUES))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CONTIGENCY-TABLE

; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2 (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables with only two values; the function
; will construct a 2x2 contingency table by counting the number of occurrences of
; each combination of the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTINGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (UNLESS (EQUAL '(2 2) (ARRAY-DIMENSIONS CL-MATHSTATS::2X2-TABLE))
;         (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;       (LET ((CL-MATHSTATS::A #)
;             (CL-MATHSTATS::B #)
;             (CL-MATHSTATS::C #)
;             (CL-MATHSTATS::D #))
;         (MULTIPLE-VALUE-CALL #'VALUES
;           (CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS CL-MATHSTATS::A
;                                                CL-MATHSTATS::B
;                                                CL-MATHSTATS::C
;                                                CL-MATHSTATS::D)
;           CL-MATHSTATS::2X2-TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::CONTINGENCY-TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2
;                            (MULTIPLE-VALUE-BIND
;                                (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                                         CL-MATHSTATS::V2-VALUES)
;                                (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                                 CL-MATHSTATS::V1
;                                 CL-MATHSTATS::V2)
;                              (UNLESS (EQUAL '# #)
;                                (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;                              (LET (# # # #)
;                                (MULTIPLE-VALUE-CALL #'VALUES
;                                  #
;                                  CL-MATHSTATS::2X2-TABLE
;                                  CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::CONTINGENCY-TABLE

; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:D-TEST
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::D-TEST
;                                   (CL-MATHSTATS::SIGNIFICANCE)
;                                   ((COUNT) (CL-MATHSTATS::TIMES))
;                                   (CL-MATHSTATS::STATISTIC CL-MATHSTATS::LEVEL
;                                                            COUNT
;                                                            CL-MATHSTATS::TIMES)
;                                   ((CL-MATHSTATS::SAMPLE-1 'SEQUENCE)
;                                    (CL-MATHSTATS::SAMPLE-2 'SEQUENCE))
;                                   (CL-MATHSTATS::SAMPLE-1
;                                    CL-MATHSTATS::SAMPLE-2
;                                    CL-MATHSTATS::TAILS
;                                    &KEY
;                                    (CL-MATHSTATS::TIMES 1000)
;                                    (CL-MATHSTATS::H0MEAN 0))
;                                   "Two-sample test for difference in means.  Competes with the unmatched,
; two-sample t-test.  Each sample should be a sequence of numbers.  We calculate
; the mean of `sample-1' minus the mean of `sample-2'; call that D.  Under the null
; hypothesis, D is zero.  There are three possible alternative hypotheses: D is
; positive, D is negative, and D is either, and they are selected by the `tails'
; parameter, which must be :positive, :negative, or :both, respectively.  We count
; the number of chance occurrences of D in the desired rejection region, and
; return the estimated probability."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::D
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            COUNT))
;                                   (CHECK-TYPE CL-MATHSTATS::SAMPLE-1 SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::SAMPLE-2 SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::TAILS
;                                               (MEMBER :BOTH
;                                                       :POSITIVE
;                                                       :NEGATIVE))
;                                   ...)
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1614 'COUNT)
; 
; caught STYLE-WARNING:
;   undefined type: COUNT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1614 'COUNT)
; 
; caught STYLE-WARNING:
;   undefined type: COUNT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::D-TEST-INTERNAL
;                          (CL-MATHSTATS::SAMPLE-1 CL-MATHSTATS::SAMPLE-2
;                                                  CL-MATHSTATS::TAILS
;                                                  &KEY
;                                                  (CL-MATHSTATS::TIMES 1000)
;                                                  (CL-MATHSTATS::H0MEAN 0))
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::D
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   COUNT))
;                          (BLOCK CL-MATHSTATS::D-TEST-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::SAMPLE-1 SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::SAMPLE-2 SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::TAILS
;                                        (MEMBER :BOTH :POSITIVE :NEGATIVE))
;                            (LET ((CL-MATHSTATS::N1 #) (CL-MATHSTATS::N2 #))
;                              (WHEN (OR # #) (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::INSUFFICIENT-DATA))
;                              (LET* (# #)
;                                (IF # # #)))))
; 
; caught STYLE-WARNING:
;   undefined type: COUNT

; 
; caught STYLE-WARNING:
;   1 more use of undefined type COUNT


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:D-TEST
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::D-TEST
;                                   (CL-MATHSTATS::SIGNIFICANCE)
;                                   ((COUNT) (CL-MATHSTATS::TIMES))
;                                   (CL-MATHSTATS::STATISTIC CL-MATHSTATS::LEVEL
;                                                            COUNT
;                                                            CL-MATHSTATS::TIMES)
;                                   ((CL-MATHSTATS::SAMPLE-1 'SEQUENCE)
;                                    (CL-MATHSTATS::SAMPLE-2 'SEQUENCE))
;                                   (CL-MATHSTATS::SAMPLE-1
;                                    CL-MATHSTATS::SAMPLE-2
;                                    CL-MATHSTATS::TAILS
;                                    &KEY
;                                    (CL-MATHSTATS::TIMES 1000)
;                                    (CL-MATHSTATS::H0MEAN 0))
;                                   "Two-sample test for difference in means.  Competes with the unmatched,
; two-sample t-test.  Each sample should be a sequence of numbers.  We calculate
; the mean of `sample-1' minus the mean of `sample-2'; call that D.  Under the null
; hypothesis, D is zero.  There are three possible alternative hypotheses: D is
; positive, D is negative, and D is either, and they are selected by the `tails'
; parameter, which must be :positive, :negative, or :both, respectively.  We count
; the number of chance occurrences of D in the desired rejection region, and
; return the estimated probability."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::D
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            COUNT))
;                                   (CHECK-TYPE CL-MATHSTATS::SAMPLE-1 SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::SAMPLE-2 SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::TAILS
;                                               (MEMBER :BOTH
;                                                       :POSITIVE
;                                                       :NEGATIVE))
;                                   ...)
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1612 'CL-MATHSTATS::D)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::D

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1612 'CL-MATHSTATS::D)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::D

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::D-TEST-INTERNAL
;                          (CL-MATHSTATS::SAMPLE-1 CL-MATHSTATS::SAMPLE-2
;                                                  CL-MATHSTATS::TAILS
;                                                  &KEY
;                                                  (CL-MATHSTATS::TIMES 1000)
;                                                  (CL-MATHSTATS::H0MEAN 0))
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::D
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   COUNT))
;                          (BLOCK CL-MATHSTATS::D-TEST-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::SAMPLE-1 SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::SAMPLE-2 SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::TAILS
;                                        (MEMBER :BOTH :POSITIVE :NEGATIVE))
;                            (LET ((CL-MATHSTATS::N1 #) (CL-MATHSTATS::N2 #))
;                              (WHEN (OR # #) (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::INSUFFICIENT-DATA))
;                              (LET* (# #)
;                                (IF # # #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::D

; 
; caught STYLE-WARNING:
;   1 more use of undefined type CL-MATHSTATS::D


; file: /Users/gwking/darcs/metatilities/dev/utilities/locks.lisp
; in: DEFGENERIC METABANG.UTILITIES::DESTROY-LOCK
;     (METABANG.UTILITIES:DEALLOCATE METABANG.UTILITIES::LOCK)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES:DEALLOCATE


; file: /Users/gwking/darcs/metatilities/dev/utilities/spy.lisp
; in: DEFUN METABANG.UTILITIES::SPY-PARSE-ARGLIST
;     (METABANG.UTILITIES::DEBUGGING-P-FN DEBUG)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES::DEBUGGING-P-FN


; file: /Users/gwking/darcs/metatilities/dev/utilities/locks.lisp
; in: DEFUN METABANG.UTILITIES::FLUSH-LOCKS-AND-TAKE-NAMES
;     (METABANG.UTILITIES:DESTROY-THREAD METABANG.UTILITIES::P)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES:DESTROY-THREAD


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-BRIEF-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates the main statistics of a linear regression: the slope and
; intercept of the line, the coefficient of determination, also known as r-square,
; the standard error of the slope, and the p-value for the regression.  This
; function differs from `linear-regression-brief' in that it takes summary
; variables: `x' and `y' are the sums of the independent variable and dependent
; variables, respectively; `x2' and `y2' are the sums of the squares of the
; independent variable and dependent variables, respectively; and `xy' is the sum
; of the products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE
;      (VALUES CL-MATHSTATS::SLOPE
;              CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::DETERMINATION
;              CL-MATHSTATS::STD-ERR-SLOPE
;              CL-MATHSTATS::P-VALUE))
;     (LET ((CL-MATHSTATS::NSSX (- # #))
;           (CL-MATHSTATS::NSSY (- # #))
;           (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (OR (ZEROP CL-MATHSTATS::NSSX) (ZEROP CL-MATHSTATS::NSSY))
;         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #)
;              (CL-MATHSTATS::INTERCEPT #)
;              (CL-MATHSTATS::NSSR #)
;              (CL-MATHSTATS::NSSE #)
;              (CL-MATHSTATS::DETERMINATION #)
;              (CL-MATHSTATS::DOF #)
;              (CL-MATHSTATS::STD-ERR-SLOPE #)
;              (CL-MATHSTATS::P-VALUE #))
;         (VALUES CL-MATHSTATS::SLOPE
;                 CL-MATHSTATS::INTERCEPT
;                 CL-MATHSTATS::DETERMINATION
;                 CL-MATHSTATS::STD-ERR-SLOPE
;                 CL-MATHSTATS::P-VALUE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G210 'CL-MATHSTATS::DETERMINATION)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DETERMINATION

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G210 'CL-MATHSTATS::DETERMINATION)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DETERMINATION

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE
;                                   CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::DETERMINATION
;                                   CL-MATHSTATS::STD-ERR-SLOPE
;                                   CL-MATHSTATS::P-VALUE))
;                          (BLOCK CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #)
;                                  (CL-MATHSTATS::NSSY #)
;                                  (CL-MATHSTATS::NSSXY #))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# # # # # # # #)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT
;                                        CL-MATHSTATS::DETERMINATION
;                                        CL-MATHSTATS::STD-ERR-SLOPE
;                                        CL-MATHSTATS::P-VALUE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DETERMINATION

; 
; caught STYLE-WARNING:
;   7 more uses of undefined type CL-MATHSTATS::DETERMINATION


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:T-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::T-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::T-SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the t-statistic for the mean of the data, which should be a sequence
; of numbers.  Let D be the sample mean.  The null hypothesis is that D equals the
; `H0-mean.' The alternative hypothesis is specified by `tails': `:both' means D
; /= H0-mean, `:positive' means D > H0-mean, and `:negative' means D < H0-mean.
; 
; The function also returns the significance, the standard error, and the degrees
; of freedom.  Signals `zero-variance' if that condition occurs.  Signals
; `insufficient-data' unless there are at least two elements in the sample."
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY)
;                                    (VALUES CL-MATHSTATS::T-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            CL-MATHSTATS::SAMPLE-ERROR
;                                            CL-MATHSTATS::DOF))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# # #)
;                                         (VALUES CL-MATHSTATS::TT
;                                                 CL-MATHSTATS::SIG
;                                                 CL-MATHSTATS::SE
;                                                 #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1388 'CL-MATHSTATS::DOF)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DOF

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1388 'CL-MATHSTATS::DOF)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DOF

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY)
;                           (VALUES CL-MATHSTATS::T-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::SAMPLE-ERROR
;                                   CL-MATHSTATS::DOF))
;                          (BLOCK CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::DOF

; 
; caught STYLE-WARNING:
;   12 more uses of undefined type CL-MATHSTATS::DOF


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:MODE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::MODE
;                                   NIL
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the most frequent element of `data,' which should be a sequence.  The
; algorithm involves sorting, and so the data must be numbers or the `key'
; function must produce numbers.  Consider `sxhash' if no better function is
; available.  Also returns the number of occurrences of the mode.  If there is
; more than one mode, this returns the first mode, as determined by the sorting of
; the numbers."
;                                   (DECLARE
;                                    (VALUES METABANG.UTILITIES:ELEMENT
;                                            CL-MATHSTATS::NUMBER-OF-OCCURRENCES))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (LET* ((CL-MATHSTATS::N
;                                           (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::START2
;                                           (OR CL-MATHSTATS::START 0))
;                                          (CL-MATHSTATS::END2
;                                           (OR CL-MATHSTATS::END #)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (CL-MATHSTATS::WITH-TEMP-VECTOR
;                                      (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                                      (REPLACE CL-MATHSTATS::TEMP
;                                               CL-MATHSTATS::DATA
;                                               :END1
;                                               CL-MATHSTATS::N
;                                               :START2
;                                               CL-MATHSTATS::START2
;                                               :END2
;                                               CL-MATHSTATS::END2)
;                                      (IF (NULL CL-MATHSTATS::KEY)
;                                          (SORT CL-MATHSTATS::TEMP #'<)
;                                          (SORT CL-MATHSTATS::TEMP
;                                                #'<
;                                                :KEY
;                                                CL-MATHSTATS::KEY))
;                                      (LET* (# # # # #)
;                                        (IF # # #)
;                                        (WHEN # #)
;                                        (VALUES CL-MATHSTATS::BIGGEST-GROUP
;                                                CL-MATHSTATS::BIGGEST-GROUP-SIZE)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G869 'METABANG.UTILITIES:ELEMENT)
; 
; caught STYLE-WARNING:
;   undefined type: METABANG.UTILITIES:ELEMENT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G869 'METABANG.UTILITIES:ELEMENT)
; 
; caught STYLE-WARNING:
;   undefined type: METABANG.UTILITIES:ELEMENT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MODE-INTERNAL
;                          (CL-MATHSTATS::DATA &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (VALUES METABANG.UTILITIES:ELEMENT
;                                   CL-MATHSTATS::NUMBER-OF-OCCURRENCES))
;                          (BLOCK CL-MATHSTATS::MODE-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (LET* ((CL-MATHSTATS::N #)
;                                   (CL-MATHSTATS::START2 #)
;                                   (CL-MATHSTATS::END2 #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (CL-MATHSTATS::WITH-TEMP-VECTOR
;                               (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                               (REPLACE CL-MATHSTATS::TEMP
;                                        CL-MATHSTATS::DATA
;                                        :END1
;                                        CL-MATHSTATS::N
;                                        :START2
;                                        CL-MATHSTATS::START2
;                                        :END2
;                                        CL-MATHSTATS::END2)
;                               (IF # # #)
;                               (LET* #
;                                 #
;                                 #
;                                 #)))))
; 
; caught STYLE-WARNING:
;   undefined type: METABANG.UTILITIES:ELEMENT

; 
; caught STYLE-WARNING:
;   1 more use of undefined type METABANG.UTILITIES:ELEMENT


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G575 'CL-MATHSTATS::F)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::F

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G575 'CL-MATHSTATS::F)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::F

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::F

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::F


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:TUKEY-SUMMARY
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::TUKEY-SUMMARY
;                                   NIL
;                                   ((CL-MATHSTATS::MINIMUM)
;                                    (CL-MATHSTATS::FIRST-QUARTILE)
;                                    (CL-MATHSTATS::MEDIAN)
;                                    (CL-MATHSTATS::THIRD-QUARTILE)
;                                    (CL-MATHSTATS::MAXIMUM))
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Computes a Tukey five-number summary of the data.  That is, it returns, in
; increasing order, the extremes and the quartiles: the minimum, the 1/4 quartile,
; the median, the 3/4 quartile, and the maximum."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MINIMUM
;                                            CL-MATHSTATS::FIRST-QUARTILE
;                                            CL-MATHSTATS::MEDIAN
;                                            CL-MATHSTATS::THIRD-QUARTILE
;                                            CL-MATHSTATS::MAXIMUM))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (LET* ((CL-MATHSTATS::N
;                                           (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::START2
;                                           (OR CL-MATHSTATS::START 0))
;                                          (CL-MATHSTATS::END2
;                                           (OR CL-MATHSTATS::END #)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (CL-MATHSTATS::WITH-TEMP-VECTOR
;                                      (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                                      (REPLACE CL-MATHSTATS::TEMP
;                                               CL-MATHSTATS::DATA
;                                               :END1
;                                               CL-MATHSTATS::N
;                                               :START2
;                                               CL-MATHSTATS::START2
;                                               :END2
;                                               CL-MATHSTATS::END2)
;                                      (IF (NULL CL-MATHSTATS::KEY)
;                                          (SORT CL-MATHSTATS::TEMP #'<)
;                                          (SORT CL-MATHSTATS::TEMP
;                                                #'<
;                                                :KEY
;                                                CL-MATHSTATS::KEY))
;                                      (FLET (#)
;                                        (VALUES # # # # #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1218 'CL-MATHSTATS::FIRST-QUARTILE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::FIRST-QUARTILE

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1218 'CL-MATHSTATS::FIRST-QUARTILE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::FIRST-QUARTILE

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::TUKEY-SUMMARY-INTERNAL
;                          (CL-MATHSTATS::DATA &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::MINIMUM
;                                   CL-MATHSTATS::FIRST-QUARTILE
;                                   CL-MATHSTATS::MEDIAN
;                                   CL-MATHSTATS::THIRD-QUARTILE
;                                   CL-MATHSTATS::MAXIMUM))
;                          (BLOCK CL-MATHSTATS::TUKEY-SUMMARY-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (LET* ((CL-MATHSTATS::N #)
;                                   (CL-MATHSTATS::START2 #)
;                                   (CL-MATHSTATS::END2 #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (CL-MATHSTATS::WITH-TEMP-VECTOR
;                               (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                               (REPLACE CL-MATHSTATS::TEMP
;                                        CL-MATHSTATS::DATA
;                                        :END1
;                                        CL-MATHSTATS::N
;                                        :START2
;                                        CL-MATHSTATS::START2
;                                        :END2
;                                        CL-MATHSTATS::END2)
;                               (IF # # #)
;                               (FLET #
;                                 #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::FIRST-QUARTILE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::FIRST-QUARTILE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::G-TEST
;     (FLET ((CL-MATHSTATS::DOIT
;              (CL-MATHSTATS::CONTINGENCY-TABLE
;               &OPTIONAL CL-MATHSTATS::EXPECTED-VALUE-MATRIX)
;            (DECLARE
;             (VALUES CL-MATHSTATS::G-SCORE
;                     CL-MATHSTATS::G-SIGNIFICANCE
;                     CL-MATHSTATS::DOF))
;            (DESTRUCTURING-BIND
;                (CL-MATHSTATS::ROWS CL-MATHSTATS::COLUMNS)
;                (ARRAY-DIMENSIONS CL-MATHSTATS::CONTINGENCY-TABLE)
;              (LET #
;                #
;                #
;                #
;                #))))
;     (IF CL-MATHSTATS::ERROR-P
;         (CL-MATHSTATS::DOIT CL-MATHSTATS::CONTINGENCY-TABLE
;                             CL-MATHSTATS::EXPECTED-VALUE-MATRIX)
;         (CATCH 'CL-MATHSTATS::RECOVER
;           (HANDLER-BIND (# #)
;                         (CL-MATHSTATS::DOIT CL-MATHSTATS::CONTINGENCY-TABLE
;                                             CL-MATHSTATS::EXPECTED-VALUE-MATRIX)))))
; --> THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND IF NOT 
; --> IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2520 'CL-MATHSTATS::G-SCORE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SCORE

; --> THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND IF NOT 
; --> IF 
; ==>
;   (TYPEP #:G2520 'CL-MATHSTATS::G-SCORE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SCORE
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SCORE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::G-SCORE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::G-TEST
;     (FLET ((CL-MATHSTATS::DOIT
;              (CL-MATHSTATS::CONTINGENCY-TABLE
;               &OPTIONAL CL-MATHSTATS::EXPECTED-VALUE-MATRIX)
;            (DECLARE
;             (VALUES CL-MATHSTATS::G-SCORE
;                     CL-MATHSTATS::G-SIGNIFICANCE
;                     CL-MATHSTATS::DOF))
;            (DESTRUCTURING-BIND
;                (CL-MATHSTATS::ROWS CL-MATHSTATS::COLUMNS)
;                (ARRAY-DIMENSIONS CL-MATHSTATS::CONTINGENCY-TABLE)
;              (LET #
;                #
;                #
;                #
;                #))))
;     (IF CL-MATHSTATS::ERROR-P
;         (CL-MATHSTATS::DOIT CL-MATHSTATS::CONTINGENCY-TABLE
;                             CL-MATHSTATS::EXPECTED-VALUE-MATRIX)
;         (CATCH 'CL-MATHSTATS::RECOVER
;           (HANDLER-BIND (# #)
;                         (CL-MATHSTATS::DOIT CL-MATHSTATS::CONTINGENCY-TABLE
;                                             CL-MATHSTATS::EXPECTED-VALUE-MATRIX)))))
; --> THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND IF NOT 
; --> IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2521 'CL-MATHSTATS::G-SIGNIFICANCE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SIGNIFICANCE

; --> THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND IF NOT 
; --> IF 
; ==>
;   (TYPEP #:G2521 'CL-MATHSTATS::G-SIGNIFICANCE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SIGNIFICANCE
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::G-SIGNIFICANCE

; 
; caught STYLE-WARNING:
;   1 more use of undefined type CL-MATHSTATS::G-SIGNIFICANCE


; file: /Users/gwking/darcs/cl-graph/dev/graph.lisp
; in:
;      DEFMETHOD CL-GRAPH:IN-CYCLE-P (CL-GRAPH:BASIC-GRAPH CL-GRAPH:BASIC-VERTEX)
;     (CL-GRAPH::GRAPH-SEARCH (LIST CL-GRAPH::START-VERTEX)
;                           (LAMBDA (CL-GRAPH::V)
;                             (IF CL-GRAPH::FIRST-TIME?
;                                 (METABANG.UTILITIES:NILF CL-GRAPH::FIRST-TIME?)
;                                 (EQ
;                                  (CL-GRAPH:FIND-VERTEX CL-GRAPH::GRAPH
;                                                        CL-GRAPH::V)
;                                  CL-GRAPH::START-VERTEX)))
;                           (LAMBDA (CL-GRAPH::V)
;                             (CL-GRAPH:CHILD-VERTEXES CL-GRAPH::V))
;                           #'APPEND
;                           :NEW-STATE-FN
;                           (LAMBDA
;                               (CL-GRAPH::STATES CL-GRAPH::SUCCESSORS
;                                CL-GRAPH::STATE= CL-GRAPH::OLD-STATES)
;                             (REMOVE-IF #'(LAMBDA (CL-GRAPH::STATE) (AND # #))
;                                        (FUNCALL CL-GRAPH::SUCCESSORS
;                                                 (FIRST CL-GRAPH::STATES)))))
; 
; caught STYLE-WARNING:
;   undefined function: CL-GRAPH::GRAPH-SEARCH


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-MINIMAL-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates the slope and intercept of the regression line.  This function
; differs from `linear-regression-minimal' in that it takes summary statistics:
; `x' and `y' are the sums of the independent variable and dependent variables,
; respectively; `x2' and `y2' are the sums of the squares of the independent
; variable and dependent variables, respectively; and `xy' is the sum of the
; products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT)
;              (IGNORE CL-MATHSTATS::Y2))
;     (LET ((CL-MATHSTATS::NSSX (- # #)) (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (ZEROP CL-MATHSTATS::NSSX) (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #) (CL-MATHSTATS::INTERCEPT #))
;         (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G181 'CL-MATHSTATS::INTERCEPT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::INTERCEPT

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G181 'CL-MATHSTATS::INTERCEPT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::INTERCEPT

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT)
;                           (IGNORE CL-MATHSTATS::Y2))
;                          (BLOCK
;                              CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #) (CL-MATHSTATS::NSSXY #))
;                              (WHEN (ZEROP CL-MATHSTATS::NSSX)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# #)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::INTERCEPT

; 
; caught STYLE-WARNING:
;   16 more uses of undefined type CL-MATHSTATS::INTERCEPT


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:STATISTICAL-SUMMARY
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::STATISTICAL-SUMMARY
;                                   (CL-MATHSTATS::DATA-LENGTH
;                                    CL-MATHSTATS::MINIMUM
;                                    CL-MATHSTATS::MAXIMUM
;                                    CL-MATHSTATS::RANGE
;                                    CL-MATHSTATS::MEDIAN
;                                    CL-MATHSTATS::MODE
;                                    CL-MATHSTATS::MEAN
;                                    CL-MATHSTATS::VARIANCE
;                                    CL-MATHSTATS::STANDARD-DEVIATION
;                                    CL-MATHSTATS::INTERQUARTILE-RANGE
;                                    CL-MATHSTATS::SKEWNESS)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Compute the length, minimum, maximum, range, median, mode, mean, variance,
; standard deviation, and interquartile-range of `sequence' from `start' to `end',
; accessed by `key'."
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END)
;                                    (VALUES LENGTH
;                                            CL-MATHSTATS::MINIMUM
;                                            CL-MATHSTATS::MAXIMUM
;                                            CL-MATHSTATS::RANGE
;                                            CL-MATHSTATS::MEDIAN
;                                            CL-MATHSTATS::MODE
;                                            CL-MATHSTATS::MEAN
;                                            CL-MATHSTATS::VARIANCE
;                                            CL-MATHSTATS::STANDARD-DEVIATION
;                                            CL-MATHSTATS::INTERQUARTILE-RANGE))
;                                   (LET* ((LENGTH
;                                           (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::MINIMUM
;                                           (APPLY #'CL-MATHSTATS::MINIMUM
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::MAXIMUM
;                                           (APPLY #'CL-MATHSTATS::MAXIMUM
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::RANGE (IF # # #))
;                                          (CL-MATHSTATS::MEDIAN
;                                           (APPLY #'CL-MATHSTATS::MEDIAN
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::MODE
;                                           (APPLY #'CL-MATHSTATS::SMART-MODE
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::MEAN
;                                           (APPLY #'CL-MATHSTATS::MEAN
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::VARIANCE
;                                           (APPLY #'CL-MATHSTATS::VARIANCE
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::SD
;                                           (SQRT CL-MATHSTATS::VARIANCE))
;                                          (CL-MATHSTATS::IQR
;                                           (APPLY
;                                            #'CL-MATHSTATS::INTERQUARTILE-RANGE
;                                            CL-MATHSTATS::DATA
;                                            CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::SKEWNESS
;                                           (APPLY #'CL-MATHSTATS::SKEWNESS
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS)))
;                                     (VALUES LENGTH
;                                             CL-MATHSTATS::MINIMUM
;                                             CL-MATHSTATS::MAXIMUM
;                                             CL-MATHSTATS::RANGE
;                                             CL-MATHSTATS::MEDIAN
;                                             CL-MATHSTATS::MODE
;                                             CL-MATHSTATS::MEAN
;                                             CL-MATHSTATS::VARIANCE
;                                             CL-MATHSTATS::SD
;                                             CL-MATHSTATS::IQR
;                                             CL-MATHSTATS::SKEWNESS)))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1285 'LENGTH)
; 
; caught STYLE-WARNING:
;   undefined type: LENGTH

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1285 'LENGTH)
; 
; caught STYLE-WARNING:
;   undefined type: LENGTH

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::STATISTICAL-SUMMARY-INTERNAL
;                          (CL-MATHSTATS::DATA &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START CL-MATHSTATS::END)
;                           (VALUES LENGTH
;                                   CL-MATHSTATS::MINIMUM
;                                   CL-MATHSTATS::MAXIMUM
;                                   CL-MATHSTATS::RANGE
;                                   CL-MATHSTATS::MEDIAN
;                                   CL-MATHSTATS::MODE
;                                   CL-MATHSTATS::MEAN
;                                   CL-MATHSTATS::VARIANCE
;                                   CL-MATHSTATS::STANDARD-DEVIATION
;                                   CL-MATHSTATS::INTERQUARTILE-RANGE))
;                          (BLOCK CL-MATHSTATS::STATISTICAL-SUMMARY-INTERNAL
;                            (LET* ((LENGTH #)
;                                   (CL-MATHSTATS::MINIMUM #)
;                                   (CL-MATHSTATS::MAXIMUM #)
;                                   (CL-MATHSTATS::RANGE #)
;                                   (CL-MATHSTATS::MEDIAN #)
;                                   (CL-MATHSTATS::MODE #)
;                                   (CL-MATHSTATS::MEAN #)
;                                   (CL-MATHSTATS::VARIANCE #)
;                                   (CL-MATHSTATS::SD #)
;                                   (CL-MATHSTATS::IQR #)
;                                   (CL-MATHSTATS::SKEWNESS #))
;                              (VALUES LENGTH
;                                      CL-MATHSTATS::MINIMUM
;                                      CL-MATHSTATS::MAXIMUM
;                                      CL-MATHSTATS::RANGE
;                                      CL-MATHSTATS::MEDIAN
;                                      CL-MATHSTATS::MODE
;                                      CL-MATHSTATS::MEAN
;                                      CL-MATHSTATS::VARIANCE
;                                      CL-MATHSTATS::SD
;                                      CL-MATHSTATS::IQR
;                                      CL-MATHSTATS::SKEWNESS))))
; 
; caught STYLE-WARNING:
;   undefined type: LENGTH

; 
; caught STYLE-WARNING:
;   1 more use of undefined type LENGTH


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS:CONFIDENCE-INTERVAL-T-SUMMARIES
;     (DEFUN CL-MATHSTATS::CONFIDENCE-INTERVAL-T-SUMMARIES
;          (CL-MATHSTATS::MEAN CL-MATHSTATS::DOF CL-MATHSTATS::STANDARD-ERROR
;           CL-MATHSTATS::CONFIDENCE)
;     "This function is just like `confidence-interval-t,' except that instead of
; its arguments being the actual data, it takes the following summary statistics:
; `mean,' which is the estimator of some t-distributed parameter; `dof,' which is
; the number of degrees of freedom in estimating the mean; and the
; `standard-error' of the estimator.  In general, `mean' is a point estimator of
; the mean of a t-distribution, which may be the slope parameter of a regression,
; the difference between two means, or other practical t-distributions.
; `Confidence' should be a number between 0 and 1, exclusive."
;     (DECLARE
;      (VALUES CL-MATHSTATS::MEAN CL-MATHSTATS::LOWER CL-MATHSTATS::UPPER))
;     (CHECK-TYPE CL-MATHSTATS::DOF (REAL 1 *))
;     (CHECK-TYPE CL-MATHSTATS::MEAN REAL)
;     (CHECK-TYPE CL-MATHSTATS::STANDARD-ERROR REAL)
;     (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL (0) (1)))
;     (LET* ((CL-MATHSTATS::T-X (CL-MATHSTATS::FIND-CRITICAL-VALUE #'# #))
;            (CL-MATHSTATS::W (* CL-MATHSTATS::STANDARD-ERROR CL-MATHSTATS::T-X))
;            (CL-MATHSTATS::UPPER (+ CL-MATHSTATS::MEAN CL-MATHSTATS::W))
;            (CL-MATHSTATS::LOWER (- CL-MATHSTATS::MEAN CL-MATHSTATS::W)))
;       (VALUES CL-MATHSTATS::MEAN CL-MATHSTATS::LOWER CL-MATHSTATS::UPPER)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2077 'CL-MATHSTATS::LOWER)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::LOWER

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2077 'CL-MATHSTATS::LOWER)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::LOWER

; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:CONFIDENCE-INTERVAL-Z
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::CONFIDENCE-INTERVAL-Z
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                                   "Suppose you have a sample of 50 numbers and you want to compute a 90 percent
; confidence interval on the population mean.  This function is the one to use.
; Note that it makes the assumption that the sampling distribution is normal, so
; it's inappropriate for small sample sizes.  Use confidence-interval-t instead.
; It returns three values: the mean and the lower and upper bound of the
; confidence interval.  True, only two numbers are necessary, but the confidence
; intervals of other statistics may be asymmetrical and these values would be
; consistent with those confidence intervals.  This function handles 90, 95 and 99
; percent confidence intervals as special cases, so those will be quite fast.
; `Sample' should be a sequence of numbers.  `Confidence' should be a number
; between 0 and 1, exclusive."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MEAN
;                                            CL-MATHSTATS::LOWER
;                                            CL-MATHSTATS::UPPER))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::CONFIDENCE
;                                               (REAL (0) (1)))
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                                    (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                                    (SQRT
;                                     (/
;                                      (CL-MATHSTATS::VARIANCE
;                                       CL-MATHSTATS::DATA)
;                                      (LENGTH CL-MATHSTATS::DATA)))
;                                    CL-MATHSTATS::CONFIDENCE))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::MEAN
;                                   CL-MATHSTATS::LOWER
;                                   CL-MATHSTATS::UPPER))
;                          (BLOCK CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL (0) (1)))
;                            (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                             (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                             (SQRT (/ # #))
;                             CL-MATHSTATS::CONFIDENCE)))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::LOWER

; 
; caught STYLE-WARNING:
;   7 more uses of undefined type CL-MATHSTATS::LOWER


; file: /Users/gwking/darcs/cl-graph/dev/graph-algorithms.lisp
; in: DEFMETHOD CL-GRAPH:FIND-CONNECTED-COMPONENTS (CL-GRAPH:BASIC-GRAPH)
;     (METABANG.CL-CONTAINERS:MAKE-ITERATOR
;    (CL-GRAPH::CONNECTED-COMPONENTS CL-GRAPH::GRAPH)
;    :UNIQUE
;    T
;    :TRANSFORM
;    #'METABANG.UTILITIES:PARENT)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.CL-CONTAINERS:MAKE-ITERATOR


; file: /Users/gwking/darcs/metatilities/dev/utilities/macros.lisp
; in: DEFUN METABANG.UTILITIES::MAKE-HCASE-TABLE
;     (METABANG.UTILITIES::MAPPEND
;    (METABANG.UTILITIES:COMPOSE #'METABANG.UTILITIES:ENSURE-LIST #'CAR)
;    METABANG.UTILITIES::CLAUSES)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES::MAPPEND


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G580 'CL-MATHSTATS::MSE-REG)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-REG

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G580 'CL-MATHSTATS::MSE-REG)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-REG

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-REG

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::MSE-REG


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G581 'CL-MATHSTATS::MSE-RES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-RES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G581 'CL-MATHSTATS::MSE-RES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-RES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::MSE-RES

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::MSE-RES


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:MODE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::MODE
;                                   NIL
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the most frequent element of `data,' which should be a sequence.  The
; algorithm involves sorting, and so the data must be numbers or the `key'
; function must produce numbers.  Consider `sxhash' if no better function is
; available.  Also returns the number of occurrences of the mode.  If there is
; more than one mode, this returns the first mode, as determined by the sorting of
; the numbers."
;                                   (DECLARE
;                                    (VALUES METABANG.UTILITIES:ELEMENT
;                                            CL-MATHSTATS::NUMBER-OF-OCCURRENCES))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (LET* ((CL-MATHSTATS::N
;                                           (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::START2
;                                           (OR CL-MATHSTATS::START 0))
;                                          (CL-MATHSTATS::END2
;                                           (OR CL-MATHSTATS::END #)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (CL-MATHSTATS::WITH-TEMP-VECTOR
;                                      (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                                      (REPLACE CL-MATHSTATS::TEMP
;                                               CL-MATHSTATS::DATA
;                                               :END1
;                                               CL-MATHSTATS::N
;                                               :START2
;                                               CL-MATHSTATS::START2
;                                               :END2
;                                               CL-MATHSTATS::END2)
;                                      (IF (NULL CL-MATHSTATS::KEY)
;                                          (SORT CL-MATHSTATS::TEMP #'<)
;                                          (SORT CL-MATHSTATS::TEMP
;                                                #'<
;                                                :KEY
;                                                CL-MATHSTATS::KEY))
;                                      (LET* (# # # # #)
;                                        (IF # # #)
;                                        (WHEN # #)
;                                        (VALUES CL-MATHSTATS::BIGGEST-GROUP
;                                                CL-MATHSTATS::BIGGEST-GROUP-SIZE)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G870 'CL-MATHSTATS::NUMBER-OF-OCCURRENCES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::NUMBER-OF-OCCURRENCES

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G870 'CL-MATHSTATS::NUMBER-OF-OCCURRENCES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::NUMBER-OF-OCCURRENCES

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MODE-INTERNAL
;                          (CL-MATHSTATS::DATA &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (VALUES METABANG.UTILITIES:ELEMENT
;                                   CL-MATHSTATS::NUMBER-OF-OCCURRENCES))
;                          (BLOCK CL-MATHSTATS::MODE-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (LET* ((CL-MATHSTATS::N #)
;                                   (CL-MATHSTATS::START2 #)
;                                   (CL-MATHSTATS::END2 #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (CL-MATHSTATS::WITH-TEMP-VECTOR
;                               (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                               (REPLACE CL-MATHSTATS::TEMP
;                                        CL-MATHSTATS::DATA
;                                        :END1
;                                        CL-MATHSTATS::N
;                                        :START2
;                                        CL-MATHSTATS::START2
;                                        :END2
;                                        CL-MATHSTATS::END2)
;                               (IF # # #)
;                               (LET* #
;                                 #
;                                 #
;                                 #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::NUMBER-OF-OCCURRENCES

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::NUMBER-OF-OCCURRENCES


; file: /Users/gwking/darcs/metatilities/dev/utilities/dates-and-times.lisp
; in: DEFUN METABANG.UTILITIES:FORMAT-DATE
;     (METABANG.UTILITIES:NYI)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES:NYI


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in:
;      CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:CONFIDENCE-INTERVAL-PROPORTION
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::CONFIDENCE-INTERVAL-PROPORTION
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL)
;                                   NIL
;                                   NIL
;                                   NIL
;                                   (CL-MATHSTATS::X CL-MATHSTATS::N
;                                                    CL-MATHSTATS::CONFIDENCE)
;                                   "Suppose we have a sample of `n' things and `x' of them are ``successes.'' We
; can estimate the population proportion of successes as x/n; call it `p-hat.'
; This function computes the estimate and a confidence interval on it.  This
; function is not appropriate for small samples with p-hat far from 1/2: `x'
; should be at least 5, and so should `n'-`x.' This function returns three values:
; p-hat, and the lower and upper bounds of the confidence interval.  `Confidence'
; should be a number between 0 and 1, exclusive."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::P-HAT
;                                            CL-MATHSTATS::LOWER
;                                            CL-MATHSTATS::UPPER))
;                                   (LET ((CL-MATHSTATS::P-HAT
;                                          (/ CL-MATHSTATS::X CL-MATHSTATS::N))
;                                         (CL-MATHSTATS::STANDARD-ERROR (SQRT #)))
;                                     (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                                      CL-MATHSTATS::P-HAT
;                                      CL-MATHSTATS::STANDARD-ERROR
;                                      CL-MATHSTATS::CONFIDENCE)))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2091 'CL-MATHSTATS::P-HAT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-HAT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G2091 'CL-MATHSTATS::P-HAT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-HAT

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CONFIDENCE-INTERVAL-PROPORTION-INTERNAL
;                          (CL-MATHSTATS::X CL-MATHSTATS::N
;                                           CL-MATHSTATS::CONFIDENCE)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::P-HAT
;                                   CL-MATHSTATS::LOWER
;                                   CL-MATHSTATS::UPPER))
;                          (BLOCK
;                              CL-MATHSTATS::CONFIDENCE-INTERVAL-PROPORTION-INTERNAL
;                            (LET ((CL-MATHSTATS::P-HAT #)
;                                  (CL-MATHSTATS::STANDARD-ERROR #))
;                              (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                               CL-MATHSTATS::P-HAT
;                               CL-MATHSTATS::STANDARD-ERROR
;                               CL-MATHSTATS::CONFIDENCE))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-HAT

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::P-HAT


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;          (CL-MATHSTATS::A CL-MATHSTATS::B CL-MATHSTATS::C CL-MATHSTATS::D
;           &OPTIONAL (CL-MATHSTATS::YATES T))
;     "Runs a chi-square test for association on a simple 2 x 2 table.  If `yates'
; is nil, the correction for continuity is not done; default is t.
; 
; Returns the chi-square statistic and the significance of the value."
;     (DECLARE (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))
;     (CHECK-TYPE CL-MATHSTATS::A INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::B INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::C INTEGER)
;     (CHECK-TYPE CL-MATHSTATS::D INTEGER)
;     (LET ((CL-MATHSTATS::N
;            (+ CL-MATHSTATS::A CL-MATHSTATS::B CL-MATHSTATS::C CL-MATHSTATS::D))
;           (CL-MATHSTATS::DENOM (* # # # #))
;           (CL-MATHSTATS::NUMER (- # #)))
;       (WHEN CL-MATHSTATS::YATES (SETF CL-MATHSTATS::NUMER (- # #)))
;       (SETF CL-MATHSTATS::NUMER
;               (* CL-MATHSTATS::N (CL-MATHSTATS:SQUARE CL-MATHSTATS::NUMER)))
;       (LET* ((CL-MATHSTATS::CHI2 #) (CL-MATHSTATS::P-VALUE #))
;         (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2280 'CL-MATHSTATS::P-VALUE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-VALUE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2280 'CL-MATHSTATS::P-VALUE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-VALUE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;                          (CL-MATHSTATS::A CL-MATHSTATS::B
;                                           CL-MATHSTATS::C
;                                           CL-MATHSTATS::D
;                                           &OPTIONAL
;                                           (CL-MATHSTATS::YATES T))
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI2 CL-MATHSTATS::P-VALUE))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS
;                            (CHECK-TYPE CL-MATHSTATS::A INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::B INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::C INTEGER)
;                            (CHECK-TYPE CL-MATHSTATS::D INTEGER)
;                            (LET ((CL-MATHSTATS::N #)
;                                  (CL-MATHSTATS::DENOM #)
;                                  (CL-MATHSTATS::NUMER #))
;                              (WHEN CL-MATHSTATS::YATES
;                                (SETF CL-MATHSTATS::NUMER #))
;                              (SETF CL-MATHSTATS::NUMER (* CL-MATHSTATS::N #))
;                              (LET* (# #)
;                                (VALUES CL-MATHSTATS::CHI2
;                                        CL-MATHSTATS::P-VALUE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::P-VALUE

; 
; caught STYLE-WARNING:
;   9 more uses of undefined type CL-MATHSTATS::P-VALUE


; file: /Users/gwking/darcs/metatilities/dev/utilities/utilities.lisp
; in: DEFUN METABANG.UTILITIES:ADD-CLASS-IF-NECESSARY
;     (METABANG.UTILITIES:PUSH-END METABANG.UTILITIES::SUPERCLASS-NAME
;                                METABANG.UTILITIES::CLASS-LIST)
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES:PUSH-END


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G571 'CL-MATHSTATS::R-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G571 'CL-MATHSTATS::R-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-LIST

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::R-LIST


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G574 'CL-MATHSTATS::R-SQUARE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-SQUARE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G574 'CL-MATHSTATS::R-SQUARE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-SQUARE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::R-SQUARE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::R-SQUARE


; file: /Users/gwking/darcs/cl-containers/dev/containers-readtable.lisp
; in: SET-MACRO-CHARACTER #\[
;     (METABANG.CL-CONTAINERS::READ-CONTAINER-ELEMENT STREAM #\])
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.CL-CONTAINERS::READ-CONTAINER-ELEMENT


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:T-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::T-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::T-SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the t-statistic for the mean of the data, which should be a sequence
; of numbers.  Let D be the sample mean.  The null hypothesis is that D equals the
; `H0-mean.' The alternative hypothesis is specified by `tails': `:both' means D
; /= H0-mean, `:positive' means D > H0-mean, and `:negative' means D < H0-mean.
; 
; The function also returns the significance, the standard error, and the degrees
; of freedom.  Signals `zero-variance' if that condition occurs.  Signals
; `insufficient-data' unless there are at least two elements in the sample."
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY)
;                                    (VALUES CL-MATHSTATS::T-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            CL-MATHSTATS::SAMPLE-ERROR
;                                            CL-MATHSTATS::DOF))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# # #)
;                                         (VALUES CL-MATHSTATS::TT
;                                                 CL-MATHSTATS::SIG
;                                                 CL-MATHSTATS::SE
;                                                 #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1387 'CL-MATHSTATS::SAMPLE-ERROR)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SAMPLE-ERROR

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1387 'CL-MATHSTATS::SAMPLE-ERROR)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SAMPLE-ERROR

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY)
;                           (VALUES CL-MATHSTATS::T-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::SAMPLE-ERROR
;                                   CL-MATHSTATS::DOF))
;                          (BLOCK CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SAMPLE-ERROR

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::SAMPLE-ERROR


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-MINIMAL-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates the slope and intercept of the regression line.  This function
; differs from `linear-regression-minimal' in that it takes summary statistics:
; `x' and `y' are the sums of the independent variable and dependent variables,
; respectively; `x2' and `y2' are the sums of the squares of the independent
; variable and dependent variables, respectively; and `xy' is the sum of the
; products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT)
;              (IGNORE CL-MATHSTATS::Y2))
;     (LET ((CL-MATHSTATS::NSSX (- # #)) (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (ZEROP CL-MATHSTATS::NSSX) (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #) (CL-MATHSTATS::INTERCEPT #))
;         (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G180 'CL-MATHSTATS::SLOPE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SLOPE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G180 'CL-MATHSTATS::SLOPE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SLOPE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE CL-MATHSTATS::INTERCEPT)
;                           (IGNORE CL-MATHSTATS::Y2))
;                          (BLOCK
;                              CL-MATHSTATS::LINEAR-REGRESSION-MINIMAL-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #) (CL-MATHSTATS::NSSXY #))
;                              (WHEN (ZEROP CL-MATHSTATS::NSSX)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# #)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SLOPE

; 
; caught STYLE-WARNING:
;   12 more uses of undefined type CL-MATHSTATS::SLOPE


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G577 'CL-MATHSTATS::SS-PERCENT-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-PERCENT-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G577 'CL-MATHSTATS::SS-PERCENT-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-PERCENT-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-PERCENT-LIST

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::SS-PERCENT-LIST


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G578 'CL-MATHSTATS::SS-REG)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G578 'CL-MATHSTATS::SS-REG)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::SS-REG


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G576 'CL-MATHSTATS::SS-REG-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G576 'CL-MATHSTATS::SS-REG-LIST)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG-LIST

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-REG-LIST

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::SS-REG-LIST


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G579 'CL-MATHSTATS::SS-RES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-RES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G579 'CL-MATHSTATS::SS-RES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-RES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::SS-RES

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::SS-RES


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-VERBOSE-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates almost every statistic of a linear regression: the slope and
; intercept of the line, the standard error on each, the correlation coefficient,
; the coefficient of determination, also known as r-square, and an ANOVA table as
; described in the manual.
; 
; If you don't need all this information, consider using the ``-brief'' or
; ``-minimal'' functions, which do less computation.
; 
; This function differs from `linear-regression-verbose' in that it takes summary
; variables: `x' and `y' are the sums of the independent variable and dependent
; variables, respectively; `x2' and `y2' are the sums of the squares of the
; independent variable and dependent variables, respectively; and `xy' is the sum
; of the products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE
;      (VALUES CL-MATHSTATS::SLOPE
;              CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::DETERMINATION
;              CL-MATHSTATS::CORRELATION
;              CL-MATHSTATS::STD-ERR-SLOPE
;              CL-MATHSTATS::STD-ERR-INTERCEPT
;              CL-MATHSTATS::ANOVA-TABLE))
;     (LET ((CL-MATHSTATS::NSSX (- # #))
;           (CL-MATHSTATS::NSSY (- # #))
;           (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (OR (ZEROP CL-MATHSTATS::NSSX) (ZEROP CL-MATHSTATS::NSSY))
;         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #)
;              (CL-MATHSTATS::INTERCEPT #)
;              (CL-MATHSTATS::NSSR #)
;              (CL-MATHSTATS::NSSE #)
;              (CL-MATHSTATS::DETERMINATION #)
;              (CL-MATHSTATS::CORRELATION #)
;              (CL-MATHSTATS::DOF #)
;              (CL-MATHSTATS::STD-ERR-SLOPE #)
;              (CL-MATHSTATS::STD-ERR-INTERCEPT NIL)
;              (CL-MATHSTATS::F #)
;              (CL-MATHSTATS::P-VALUE #)
;              (CL-MATHSTATS::SSR #)
;              ...)
;         (VALUES CL-MATHSTATS::SLOPE
;                 CL-MATHSTATS::INTERCEPT
;                 CL-MATHSTATS::DETERMINATION
;                 CL-MATHSTATS::CORRELATION
;                 CL-MATHSTATS::STD-ERR-SLOPE
;                 CL-MATHSTATS::STD-ERR-INTERCEPT
;                 CL-MATHSTATS::ANOVA-TABLE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G246 'CL-MATHSTATS::STD-ERR-INTERCEPT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-INTERCEPT

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G246 'CL-MATHSTATS::STD-ERR-INTERCEPT)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-INTERCEPT

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE
;                                   CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::DETERMINATION
;                                   CL-MATHSTATS::CORRELATION
;                                   CL-MATHSTATS::STD-ERR-SLOPE
;                                   CL-MATHSTATS::STD-ERR-INTERCEPT
;                                   CL-MATHSTATS::ANOVA-TABLE))
;                          (BLOCK
;                              CL-MATHSTATS::LINEAR-REGRESSION-VERBOSE-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #)
;                                  (CL-MATHSTATS::NSSY #)
;                                  (CL-MATHSTATS::NSSXY #))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# # # # # # # # # # # # ...)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT
;                                        CL-MATHSTATS::DETERMINATION
;                                        CL-MATHSTATS::CORRELATION
;                                        CL-MATHSTATS::STD-ERR-SLOPE
;                                        CL-MATHSTATS::STD-ERR-INTERCEPT
;                                        CL-MATHSTATS::ANOVA-TABLE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-INTERCEPT

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::STD-ERR-INTERCEPT


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:LINEAR-REGRESSION-BRIEF-SUMMARIES
;     (DEFUN CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;          (CL-MATHSTATS::N CL-MATHSTATS::X CL-MATHSTATS::Y CL-MATHSTATS::X2
;           CL-MATHSTATS::Y2 CL-MATHSTATS::XY)
;     "Calculates the main statistics of a linear regression: the slope and
; intercept of the line, the coefficient of determination, also known as r-square,
; the standard error of the slope, and the p-value for the regression.  This
; function differs from `linear-regression-brief' in that it takes summary
; variables: `x' and `y' are the sums of the independent variable and dependent
; variables, respectively; `x2' and `y2' are the sums of the squares of the
; independent variable and dependent variables, respectively; and `xy' is the sum
; of the products of the independent and dependent variables.
; 
; You should first look at your data with a scatter plot to see if a linear model
; is plausible.  See the manual for a fuller explanation of linear regression
; statistics."
;     (DECLARE
;      (VALUES CL-MATHSTATS::SLOPE
;              CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::DETERMINATION
;              CL-MATHSTATS::STD-ERR-SLOPE
;              CL-MATHSTATS::P-VALUE))
;     (LET ((CL-MATHSTATS::NSSX (- # #))
;           (CL-MATHSTATS::NSSY (- # #))
;           (CL-MATHSTATS::NSSXY (- # #)))
;       (WHEN (OR (ZEROP CL-MATHSTATS::NSSX) (ZEROP CL-MATHSTATS::NSSY))
;         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;       (LET* ((CL-MATHSTATS::SLOPE #)
;              (CL-MATHSTATS::INTERCEPT #)
;              (CL-MATHSTATS::NSSR #)
;              (CL-MATHSTATS::NSSE #)
;              (CL-MATHSTATS::DETERMINATION #)
;              (CL-MATHSTATS::DOF #)
;              (CL-MATHSTATS::STD-ERR-SLOPE #)
;              (CL-MATHSTATS::P-VALUE #))
;         (VALUES CL-MATHSTATS::SLOPE
;                 CL-MATHSTATS::INTERCEPT
;                 CL-MATHSTATS::DETERMINATION
;                 CL-MATHSTATS::STD-ERR-SLOPE
;                 CL-MATHSTATS::P-VALUE))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G211 'CL-MATHSTATS::STD-ERR-SLOPE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-SLOPE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G211 'CL-MATHSTATS::STD-ERR-SLOPE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-SLOPE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;                          (CL-MATHSTATS::N CL-MATHSTATS::X
;                                           CL-MATHSTATS::Y
;                                           CL-MATHSTATS::X2
;                                           CL-MATHSTATS::Y2
;                                           CL-MATHSTATS::XY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::SLOPE
;                                   CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::DETERMINATION
;                                   CL-MATHSTATS::STD-ERR-SLOPE
;                                   CL-MATHSTATS::P-VALUE))
;                          (BLOCK CL-MATHSTATS::LINEAR-REGRESSION-BRIEF-SUMMARIES
;                            (LET ((CL-MATHSTATS::NSSX #)
;                                  (CL-MATHSTATS::NSSY #)
;                                  (CL-MATHSTATS::NSSXY #))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                              (LET* (# # # # # # # #)
;                                (VALUES CL-MATHSTATS::SLOPE
;                                        CL-MATHSTATS::INTERCEPT
;                                        CL-MATHSTATS::DETERMINATION
;                                        CL-MATHSTATS::STD-ERR-SLOPE
;                                        CL-MATHSTATS::P-VALUE)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERR-SLOPE

; 
; caught STYLE-WARNING:
;   7 more uses of undefined type CL-MATHSTATS::STD-ERR-SLOPE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:T-TEST
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::T-TEST
;                                   (CL-MATHSTATS::T-SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::SAMPLE-1 'SEQUENCE)
;                                    (CL-MATHSTATS::SAMPLE-2 'SEQUENCE))
;                                   (CL-MATHSTATS::SAMPLE-1
;                                    CL-MATHSTATS::SAMPLE-2
;                                    &OPTIONAL
;                                    (CL-MATHSTATS::TAILS :BOTH)
;                                    (CL-MATHSTATS::H0MEAN 0))
;                                   "Returns the t-statistic for the difference in the means of two samples, which
; should each be a sequence of numbers.  Let D=mean1-mean2.  The null hypothesis
; is that D=0.  The alternative hypothesis is specified by `tails': `:both' means
; D/=0, `:positive' means D>0, and `:negative' means D<0.  Unless you're using
; :both tails, be careful what order the two samples are in: it matters!
; 
; The function also returns the significance, the standard error, and the degrees
; of freedom.  Signals `standard-error-is-zero' if that condition occurs.  Signals
; `insufficient-data' unless there are at least two elements in each sample."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::T-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            CL-MATHSTATS::STD-ERROR
;                                            CL-MATHSTATS::DOF))
;                                   (CHECK-TYPE CL-MATHSTATS::TAILS
;                                               (MEMBER :BOTH
;                                                       :POSITIVE
;                                                       :NEGATIVE))
;                                   (LET ((CL-MATHSTATS::N1
;                                          (CL-MATHSTATS::DATA-LENGTH
;                                           CL-MATHSTATS::SAMPLE-1))
;                                         (CL-MATHSTATS::N2
;                                          (CL-MATHSTATS::DATA-LENGTH
;                                           CL-MATHSTATS::SAMPLE-2)))
;                                     (WHEN
;                                         (OR (ZEROP CL-MATHSTATS::N1)
;                                             (ZEROP CL-MATHSTATS::N2))
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (WHEN
;                                         (OR (< CL-MATHSTATS::N1 2)
;                                             (< CL-MATHSTATS::N2 2))
;                                       (ERROR 'CL-MATHSTATS::INSUFFICIENT-DATA))
;                                     (LET* ((CL-MATHSTATS::MEAN1 #)
;                                            (CL-MATHSTATS::MEAN2 #)
;                                            (CL-MATHSTATS::SS1 #)
;                                            (CL-MATHSTATS::SS2 #)
;                                            (CL-MATHSTATS::DOF #)
;                                            (CL-MATHSTATS::SP #))
;                                       (WHEN (ZEROP CL-MATHSTATS::SP)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# # #)
;                                         (VALUES CL-MATHSTATS::T-STATISTIC
;                                                 CL-MATHSTATS::SIGNIFICANCE
;                                                 CL-MATHSTATS::STD-ERROR
;                                                 CL-MATHSTATS::DOF)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1447 'CL-MATHSTATS::STD-ERROR)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERROR

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1447 'CL-MATHSTATS::STD-ERROR)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERROR

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::T-TEST-INTERNAL
;                          (CL-MATHSTATS::SAMPLE-1 CL-MATHSTATS::SAMPLE-2
;                                                  &OPTIONAL
;                                                  (CL-MATHSTATS::TAILS :BOTH)
;                                                  (CL-MATHSTATS::H0MEAN 0))
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::T-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::STD-ERROR
;                                   CL-MATHSTATS::DOF))
;                          (BLOCK CL-MATHSTATS::T-TEST-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::TAILS
;                                        (MEMBER :BOTH :POSITIVE :NEGATIVE))
;                            (LET ((CL-MATHSTATS::N1 #) (CL-MATHSTATS::N2 #))
;                              (WHEN (OR # #) (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (WHEN (OR # #)
;                                (ERROR 'CL-MATHSTATS::INSUFFICIENT-DATA))
;                              (LET* (# # # # # #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::STD-ERROR

; 
; caught STYLE-WARNING:
;   5 more uses of undefined type CL-MATHSTATS::STD-ERROR


; file: /Users/gwking/darcs/cl-mathstats/dev/correlation-regression.lisp
; in: DEFUN CL-MATHSTATS:MULTIPLE-LINEAR-REGRESSION-NORMAL
;     (DEFUN CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;     "Performs linear regression of the dependent variable, `dv,' on multiple
; independent variables, `ivs.' Y on multiple X's, calculating the intercept and
; regression coefficient.  Calculates the F statistic, intercept and the
; correlation coefficient for Y on X's."
;     (DECLARE
;      (VALUES CL-MATHSTATS::INTERCEPT
;              CL-MATHSTATS::COEFFICIENTS
;              CL-MATHSTATS::R-LIST
;              CL-MATHSTATS::T-BS
;              CL-MATHSTATS::BETAS
;              CL-MATHSTATS::R-SQUARE
;              CL-MATHSTATS::F
;              CL-MATHSTATS::SS-REG-LIST
;              CL-MATHSTATS::SS-PERCENT-LIST
;              CL-MATHSTATS::SS-REG
;              CL-MATHSTATS::SS-RES
;              ...))
;     (LET* ((CL-MATHSTATS::NUM-X (LENGTH CL-MATHSTATS::IVS))
;            (CL-MATHSTATS::ROWS (+ 2 CL-MATHSTATS::NUM-X))
;            (CL-MATHSTATS::COLS (LENGTH CL-MATHSTATS::DV))
;            (CL-MATHSTATS::X-0
;             (MAKE-LIST CL-MATHSTATS::COLS :INITIAL-ELEMENT 1))
;            (CL-MATHSTATS::ITEM-LIST NIL))
;       (WHEN (MEMBER 'NIL CL-MATHSTATS::DV) (ERROR 'CL-MATHSTATS::MISSING-DATA))
;       (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;       (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;         (WHEN (MEMBER 'NIL CL-MATHSTATS::X)
;           (ERROR 'CL-MATHSTATS::MISSING-DATA))
;         (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;       (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;       (LET* ((CL-MATHSTATS::Z-TRANS-MAT #)
;              (CL-MATHSTATS::Z-MAT #)
;              (CL-MATHSTATS::Z-TRANS-Z #)
;              (CL-MATHSTATS::X-DIM #)
;              (CL-MATHSTATS::X-TRANS-X #)
;              (CL-MATHSTATS::X-TRANS-Y #)
;              (CL-MATHSTATS::Y-TRANS-Y #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (DOTIMES (CL-MATHSTATS::I #) (DOTIMES # #))
;         (SETF (AREF CL-MATHSTATS::Y-TRANS-Y 0 0)
;                 (AREF CL-MATHSTATS::Z-TRANS-Z
;                       CL-MATHSTATS::X-DIM
;                       CL-MATHSTATS::X-DIM))
;         (LET (#)
;           (UNLESS CL-MATHSTATS::INV-X-T-X #)
;           (LET* #
;             #
;             #
;             #
;             #)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G572 'CL-MATHSTATS::T-BS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-BS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G572 'CL-MATHSTATS::T-BS)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-BS

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                          (CL-MATHSTATS::DV &REST CL-MATHSTATS::IVS)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::INTERCEPT
;                                   CL-MATHSTATS::COEFFICIENTS
;                                   CL-MATHSTATS::R-LIST
;                                   CL-MATHSTATS::T-BS
;                                   CL-MATHSTATS::BETAS
;                                   CL-MATHSTATS::R-SQUARE
;                                   CL-MATHSTATS::F
;                                   CL-MATHSTATS::SS-REG-LIST
;                                   CL-MATHSTATS::SS-PERCENT-LIST
;                                   CL-MATHSTATS::SS-REG
;                                   CL-MATHSTATS::SS-RES
;                                   ...))
;                          (BLOCK CL-MATHSTATS::MULTIPLE-LINEAR-REGRESSION-NORMAL
;                            (LET* ((CL-MATHSTATS::NUM-X #)
;                                   (CL-MATHSTATS::ROWS #)
;                                   (CL-MATHSTATS::COLS #)
;                                   (CL-MATHSTATS::X-0 #)
;                                   (CL-MATHSTATS::ITEM-LIST NIL))
;                              (WHEN (MEMBER 'NIL CL-MATHSTATS::DV)
;                                (ERROR 'CL-MATHSTATS::MISSING-DATA))
;                              (PUSH CL-MATHSTATS::X-0 CL-MATHSTATS::ITEM-LIST)
;                              (DOLIST (CL-MATHSTATS::X CL-MATHSTATS::IVS)
;                                (WHEN # #)
;                                (PUSH CL-MATHSTATS::X CL-MATHSTATS::ITEM-LIST))
;                              (PUSH CL-MATHSTATS::DV CL-MATHSTATS::ITEM-LIST)
;                              (LET* (# # # # # # #)
;                                (DOTIMES # #)
;                                (DOTIMES # #)
;                                (SETF # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-BS

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::T-BS


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:T-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::T-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::T-SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Returns the t-statistic for the mean of the data, which should be a sequence
; of numbers.  Let D be the sample mean.  The null hypothesis is that D equals the
; `H0-mean.' The alternative hypothesis is specified by `tails': `:both' means D
; /= H0-mean, `:positive' means D > H0-mean, and `:negative' means D < H0-mean.
; 
; The function also returns the significance, the standard error, and the degrees
; of freedom.  Signals `zero-variance' if that condition occurs.  Signals
; `insufficient-data' unless there are at least two elements in the sample."
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY)
;                                    (VALUES CL-MATHSTATS::T-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE
;                                            CL-MATHSTATS::SAMPLE-ERROR
;                                            CL-MATHSTATS::DOF))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# # #)
;                                         (VALUES CL-MATHSTATS::TT
;                                                 CL-MATHSTATS::SIG
;                                                 CL-MATHSTATS::SE
;                                                 #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1385 'CL-MATHSTATS::T-STATISTIC)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-STATISTIC

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1385 'CL-MATHSTATS::T-STATISTIC)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-STATISTIC

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY)
;                           (VALUES CL-MATHSTATS::T-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::SAMPLE-ERROR
;                                   CL-MATHSTATS::DOF))
;                          (BLOCK CL-MATHSTATS::T-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::T-STATISTIC

; 
; caught STYLE-WARNING:
;   7 more uses of undefined type CL-MATHSTATS::T-STATISTIC


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;     (DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Counts each unique combination of an element of `v1' and an element of `v2.'
; Returns a two-dimensional table of integers."
;     (DECLARE
;      (VALUES CL-MATHSTATS::TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (LET ((CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V1)))
;       (WHEN (/= CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V2))
;         (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;       (LET ((CL-MATHSTATS::V1-VALUES #) (CL-MATHSTATS::V2-VALUES #))
;         (WHEN (OR # #)
;           (CERROR "Make it anyway"
;                   'CL-MATHSTATS::ENORMOUS-CONTINGENCY-TABLE
;                   :SIZE-OF-TABLE
;                   #))
;         (LET (#)
;           (MAP NIL #'# CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;           (VALUES CL-MATHSTATS::TABLE
;                   CL-MATHSTATS::V1-VALUES
;                   CL-MATHSTATS::V2-VALUES)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2449 'CL-MATHSTATS::TABLE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::TABLE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2449 'CL-MATHSTATS::TABLE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::TABLE

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (/= CL-MATHSTATS::N #)
;                                (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::TABLE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::TABLE


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:TUKEY-SUMMARY
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::TUKEY-SUMMARY
;                                   NIL
;                                   ((CL-MATHSTATS::MINIMUM)
;                                    (CL-MATHSTATS::FIRST-QUARTILE)
;                                    (CL-MATHSTATS::MEDIAN)
;                                    (CL-MATHSTATS::THIRD-QUARTILE)
;                                    (CL-MATHSTATS::MAXIMUM))
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   "Computes a Tukey five-number summary of the data.  That is, it returns, in
; increasing order, the extremes and the quartiles: the minimum, the 1/4 quartile,
; the median, the 3/4 quartile, and the maximum."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MINIMUM
;                                            CL-MATHSTATS::FIRST-QUARTILE
;                                            CL-MATHSTATS::MEDIAN
;                                            CL-MATHSTATS::THIRD-QUARTILE
;                                            CL-MATHSTATS::MAXIMUM))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (LET* ((CL-MATHSTATS::N
;                                           (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                  CL-MATHSTATS::DATA
;                                                  CL-MATHSTATS::STANDARD-ARGS))
;                                          (CL-MATHSTATS::START2
;                                           (OR CL-MATHSTATS::START 0))
;                                          (CL-MATHSTATS::END2
;                                           (OR CL-MATHSTATS::END #)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (CL-MATHSTATS::WITH-TEMP-VECTOR
;                                      (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                                      (REPLACE CL-MATHSTATS::TEMP
;                                               CL-MATHSTATS::DATA
;                                               :END1
;                                               CL-MATHSTATS::N
;                                               :START2
;                                               CL-MATHSTATS::START2
;                                               :END2
;                                               CL-MATHSTATS::END2)
;                                      (IF (NULL CL-MATHSTATS::KEY)
;                                          (SORT CL-MATHSTATS::TEMP #'<)
;                                          (SORT CL-MATHSTATS::TEMP
;                                                #'<
;                                                :KEY
;                                                CL-MATHSTATS::KEY))
;                                      (FLET (#)
;                                        (VALUES # # # # #)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1220 'CL-MATHSTATS::THIRD-QUARTILE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::THIRD-QUARTILE

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1220 'CL-MATHSTATS::THIRD-QUARTILE)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::THIRD-QUARTILE

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::TUKEY-SUMMARY-INTERNAL
;                          (CL-MATHSTATS::DATA &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::MINIMUM
;                                   CL-MATHSTATS::FIRST-QUARTILE
;                                   CL-MATHSTATS::MEDIAN
;                                   CL-MATHSTATS::THIRD-QUARTILE
;                                   CL-MATHSTATS::MAXIMUM))
;                          (BLOCK CL-MATHSTATS::TUKEY-SUMMARY-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (LET* ((CL-MATHSTATS::N #)
;                                   (CL-MATHSTATS::START2 #)
;                                   (CL-MATHSTATS::END2 #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (CL-MATHSTATS::WITH-TEMP-VECTOR
;                               (CL-MATHSTATS::TEMP CL-MATHSTATS::N)
;                               (REPLACE CL-MATHSTATS::TEMP
;                                        CL-MATHSTATS::DATA
;                                        :END1
;                                        CL-MATHSTATS::N
;                                        :START2
;                                        CL-MATHSTATS::START2
;                                        :END2
;                                        CL-MATHSTATS::END2)
;                               (IF # # #)
;                               (FLET #
;                                 #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::THIRD-QUARTILE

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::THIRD-QUARTILE


; file: /Users/gwking/darcs/metatilities/dev/utilities/locks.lisp
; in: DEFUN METABANG.UTILITIES::ENQUEUE-LOCK-REQUEST
;     (METABANG.UTILITIES:THREAD-WAIT :WAITING
;                                   (LAMBDA ()
;                                     (METABANG.UTILITIES::ACCESS-LOCK-P
;                                      METABANG.UTILITIES::OWNER
;                                      METABANG.UTILITIES::LOCK)))
; 
; caught STYLE-WARNING:
;   undefined function: METABANG.UTILITIES:THREAD-WAIT


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS:CONFIDENCE-INTERVAL-T-SUMMARIES
;     (DEFUN CL-MATHSTATS::CONFIDENCE-INTERVAL-T-SUMMARIES
;          (CL-MATHSTATS::MEAN CL-MATHSTATS::DOF CL-MATHSTATS::STANDARD-ERROR
;           CL-MATHSTATS::CONFIDENCE)
;     "This function is just like `confidence-interval-t,' except that instead of
; its arguments being the actual data, it takes the following summary statistics:
; `mean,' which is the estimator of some t-distributed parameter; `dof,' which is
; the number of degrees of freedom in estimating the mean; and the
; `standard-error' of the estimator.  In general, `mean' is a point estimator of
; the mean of a t-distribution, which may be the slope parameter of a regression,
; the difference between two means, or other practical t-distributions.
; `Confidence' should be a number between 0 and 1, exclusive."
;     (DECLARE
;      (VALUES CL-MATHSTATS::MEAN CL-MATHSTATS::LOWER CL-MATHSTATS::UPPER))
;     (CHECK-TYPE CL-MATHSTATS::DOF (REAL 1 *))
;     (CHECK-TYPE CL-MATHSTATS::MEAN REAL)
;     (CHECK-TYPE CL-MATHSTATS::STANDARD-ERROR REAL)
;     (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL (0) (1)))
;     (LET* ((CL-MATHSTATS::T-X (CL-MATHSTATS::FIND-CRITICAL-VALUE #'# #))
;            (CL-MATHSTATS::W (* CL-MATHSTATS::STANDARD-ERROR CL-MATHSTATS::T-X))
;            (CL-MATHSTATS::UPPER (+ CL-MATHSTATS::MEAN CL-MATHSTATS::W))
;            (CL-MATHSTATS::LOWER (- CL-MATHSTATS::MEAN CL-MATHSTATS::W)))
;       (VALUES CL-MATHSTATS::MEAN CL-MATHSTATS::LOWER CL-MATHSTATS::UPPER)))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G2078 'CL-MATHSTATS::UPPER)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::UPPER

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2078 'CL-MATHSTATS::UPPER)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::UPPER

; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:CONFIDENCE-INTERVAL-Z
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::CONFIDENCE-INTERVAL-Z
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                                   "Suppose you have a sample of 50 numbers and you want to compute a 90 percent
; confidence interval on the population mean.  This function is the one to use.
; Note that it makes the assumption that the sampling distribution is normal, so
; it's inappropriate for small sample sizes.  Use confidence-interval-t instead.
; It returns three values: the mean and the lower and upper bound of the
; confidence interval.  True, only two numbers are necessary, but the confidence
; intervals of other statistics may be asymmetrical and these values would be
; consistent with those confidence intervals.  This function handles 90, 95 and 99
; percent confidence intervals as special cases, so those will be quite fast.
; `Sample' should be a sequence of numbers.  `Confidence' should be a number
; between 0 and 1, exclusive."
;                                   (DECLARE
;                                    (VALUES CL-MATHSTATS::MEAN
;                                            CL-MATHSTATS::LOWER
;                                            CL-MATHSTATS::UPPER))
;                                   (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                                   (CHECK-TYPE CL-MATHSTATS::CONFIDENCE
;                                               (REAL (0) (1)))
;                                   (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                                    (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                                    (SQRT
;                                     (/
;                                      (CL-MATHSTATS::VARIANCE
;                                       CL-MATHSTATS::DATA)
;                                      (LENGTH CL-MATHSTATS::DATA)))
;                                    CL-MATHSTATS::CONFIDENCE))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::CONFIDENCE)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::MEAN
;                                   CL-MATHSTATS::LOWER
;                                   CL-MATHSTATS::UPPER))
;                          (BLOCK CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-INTERNAL
;                            (CHECK-TYPE CL-MATHSTATS::DATA SEQUENCE)
;                            (CHECK-TYPE CL-MATHSTATS::CONFIDENCE (REAL (0) (1)))
;                            (CL-MATHSTATS::CONFIDENCE-INTERVAL-Z-SUMMARIES
;                             (CL-MATHSTATS::MEAN CL-MATHSTATS::DATA)
;                             (SQRT (/ # #))
;                             CL-MATHSTATS::CONFIDENCE)))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::UPPER

; 
; caught STYLE-WARNING:
;   7 more uses of undefined type CL-MATHSTATS::UPPER


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;     (DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Counts each unique combination of an element of `v1' and an element of `v2.'
; Returns a two-dimensional table of integers."
;     (DECLARE
;      (VALUES CL-MATHSTATS::TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (LET ((CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V1)))
;       (WHEN (/= CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V2))
;         (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;       (LET ((CL-MATHSTATS::V1-VALUES #) (CL-MATHSTATS::V2-VALUES #))
;         (WHEN (OR # #)
;           (CERROR "Make it anyway"
;                   'CL-MATHSTATS::ENORMOUS-CONTINGENCY-TABLE
;                   :SIZE-OF-TABLE
;                   #))
;         (LET (#)
;           (MAP NIL #'# CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;           (VALUES CL-MATHSTATS::TABLE
;                   CL-MATHSTATS::V1-VALUES
;                   CL-MATHSTATS::V2-VALUES)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2450 'CL-MATHSTATS::V1-VALUES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V1-VALUES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (/= CL-MATHSTATS::N #)
;                                (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V1-VALUES

; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2 (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables with only two values; the function
; will construct a 2x2 contingency table by counting the number of occurrences of
; each combination of the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTINGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (UNLESS (EQUAL '(2 2) (ARRAY-DIMENSIONS CL-MATHSTATS::2X2-TABLE))
;         (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;       (LET ((CL-MATHSTATS::A #)
;             (CL-MATHSTATS::B #)
;             (CL-MATHSTATS::C #)
;             (CL-MATHSTATS::D #))
;         (MULTIPLE-VALUE-CALL #'VALUES
;           (CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS CL-MATHSTATS::A
;                                                CL-MATHSTATS::B
;                                                CL-MATHSTATS::C
;                                                CL-MATHSTATS::D)
;           CL-MATHSTATS::2X2-TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::CONTINGENCY-TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2
;                            (MULTIPLE-VALUE-BIND
;                                (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                                         CL-MATHSTATS::V2-VALUES)
;                                (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                                 CL-MATHSTATS::V1
;                                 CL-MATHSTATS::V2)
;                              (UNLESS (EQUAL '# #)
;                                (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;                              (LET (# # # #)
;                                (MULTIPLE-VALUE-CALL #'VALUES
;                                  #
;                                  CL-MATHSTATS::2X2-TABLE
;                                  CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V1-VALUES

; 
; caught STYLE-WARNING:
;   4 more uses of undefined type CL-MATHSTATS::V1-VALUES


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;     (DEFUN CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Counts each unique combination of an element of `v1' and an element of `v2.'
; Returns a two-dimensional table of integers."
;     (DECLARE
;      (VALUES CL-MATHSTATS::TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (LET ((CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V1)))
;       (WHEN (/= CL-MATHSTATS::N (LENGTH CL-MATHSTATS::V2))
;         (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;       (LET ((CL-MATHSTATS::V1-VALUES #) (CL-MATHSTATS::V2-VALUES #))
;         (WHEN (OR # #)
;           (CERROR "Make it anyway"
;                   'CL-MATHSTATS::ENORMOUS-CONTINGENCY-TABLE
;                   :SIZE-OF-TABLE
;                   #))
;         (LET (#)
;           (MAP NIL #'# CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;           (VALUES CL-MATHSTATS::TABLE
;                   CL-MATHSTATS::V1-VALUES
;                   CL-MATHSTATS::V2-VALUES)))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; --> FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION UNLESS COND 
; --> IF NOT IF 
; ==>
;   (TYPEP #:G2451 'CL-MATHSTATS::V2-VALUES)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V2-VALUES

; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (/= CL-MATHSTATS::N #)
;                                (ERROR 'CL-MATHSTATS::UNMATCHED-SEQUENCES))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET #
;                                  #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V2-VALUES

; in: DEFUN CL-MATHSTATS::CHI-SQUARE-2X2
;     (DEFUN CL-MATHSTATS::CHI-SQUARE-2X2 (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;     "Performs a chi-square test for independence of the two variables, `v1' and
; `v2.' These should be categorial variables with only two values; the function
; will construct a 2x2 contingency table by counting the number of occurrences of
; each combination of the variables.  See the manual for more details."
;     (DECLARE
;      (VALUES CL-MATHSTATS::CHI-SQUARE
;              CL-MATHSTATS::SIGNIFICANCE
;              CL-MATHSTATS::CONTINGENCY-TABLE
;              CL-MATHSTATS::V1-VALUES
;              CL-MATHSTATS::V2-VALUES))
;     (MULTIPLE-VALUE-BIND
;         (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)
;         (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE CL-MATHSTATS::V1
;                                               CL-MATHSTATS::V2)
;       (UNLESS (EQUAL '(2 2) (ARRAY-DIMENSIONS CL-MATHSTATS::2X2-TABLE))
;         (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;       (LET ((CL-MATHSTATS::A #)
;             (CL-MATHSTATS::B #)
;             (CL-MATHSTATS::C #)
;             (CL-MATHSTATS::D #))
;         (MULTIPLE-VALUE-CALL #'VALUES
;           (CL-MATHSTATS::CHI-SQUARE-2X2-COUNTS CL-MATHSTATS::A
;                                                CL-MATHSTATS::B
;                                                CL-MATHSTATS::C
;                                                CL-MATHSTATS::D)
;           CL-MATHSTATS::2X2-TABLE
;           CL-MATHSTATS::V1-VALUES
;           CL-MATHSTATS::V2-VALUES))))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::CHI-SQUARE-2X2
;                          (CL-MATHSTATS::V1 CL-MATHSTATS::V2)
;                          (DECLARE
;                           (VALUES CL-MATHSTATS::CHI-SQUARE
;                                   CL-MATHSTATS::SIGNIFICANCE
;                                   CL-MATHSTATS::CONTINGENCY-TABLE
;                                   CL-MATHSTATS::V1-VALUES
;                                   CL-MATHSTATS::V2-VALUES))
;                          (BLOCK CL-MATHSTATS::CHI-SQUARE-2X2
;                            (MULTIPLE-VALUE-BIND
;                                (CL-MATHSTATS::2X2-TABLE CL-MATHSTATS::V1-VALUES
;                                                         CL-MATHSTATS::V2-VALUES)
;                                (CL-MATHSTATS::MAKE-CONTINGENCY-TABLE
;                                 CL-MATHSTATS::V1
;                                 CL-MATHSTATS::V2)
;                              (UNLESS (EQUAL '# #)
;                                (ERROR 'CL-MATHSTATS::NOT-BINARY-VARIABLES))
;                              (LET (# # # #)
;                                (MULTIPLE-VALUE-CALL #'VALUES
;                                  #
;                                  CL-MATHSTATS::2X2-TABLE
;                                  CL-MATHSTATS::V1-VALUES
;                                  CL-MATHSTATS::V2-VALUES)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::V2-VALUES

; 
; caught STYLE-WARNING:
;   4 more uses of undefined type CL-MATHSTATS::V2-VALUES


; file: /Users/gwking/darcs/cl-mathstats/dev/basic-statistics.lisp
; in: CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS:Z-TEST-ONE-SAMPLE
;     (CL-MATHSTATS::DEFINE-STATISTIC CL-MATHSTATS::Z-TEST-ONE-SAMPLE
;                                   (CL-MATHSTATS::SIGNIFICANCE)
;                                   NIL
;                                   NIL
;                                   ((CL-MATHSTATS::DATA 'SEQUENCE))
;                                   (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                                       &OPTIONAL
;                                                       (CL-MATHSTATS::H0-MEAN 0)
;                                                       (CL-MATHSTATS::H0-STD-DEV
;                                                        1)
;                                                       &REST
;                                                       CL-MATHSTATS::STANDARD-ARGS
;                                                       &KEY
;                                                       CL-MATHSTATS::START
;                                                       CL-MATHSTATS::END
;                                                       CL-MATHSTATS::KEY)
;                                   (DECLARE
;                                    (IGNORE CL-MATHSTATS::START
;                                            CL-MATHSTATS::END
;                                            CL-MATHSTATS::KEY
;                                            CL-MATHSTATS::TAILS)
;                                    (VALUES CL-MATHSTATS::Z-STATISTIC
;                                            CL-MATHSTATS::SIGNIFICANCE))
;                                   (LET ((CL-MATHSTATS::N
;                                          (APPLY #'CL-MATHSTATS::DATA-LENGTH
;                                                 CL-MATHSTATS::DATA
;                                                 CL-MATHSTATS::STANDARD-ARGS)))
;                                     (WHEN (ZEROP CL-MATHSTATS::N)
;                                       (ERROR 'CL-MATHSTATS::NO-DATA))
;                                     (LET ((CL-MATHSTATS::D #)
;                                           (CL-MATHSTATS::V #))
;                                       (WHEN (ZEROP CL-MATHSTATS::V)
;                                         (ERROR 'CL-MATHSTATS::ZERO-VARIANCE))
;                                       (LET* (# CL-MATHSTATS::SIG)
;                                         (VALUES CL-MATHSTATS::ZS
;                                                 CL-MATHSTATS::SIG)))))
; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF TYPEP 
; ==>
;   (SB-KERNEL:%TYPEP #:G1716 'CL-MATHSTATS::Z-STATISTIC)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::Z-STATISTIC

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION THE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> FUNCTION UNLESS COND IF NOT IF 
; ==>
;   (TYPEP #:G1716 'CL-MATHSTATS::Z-STATISTIC)
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::Z-STATISTIC

; --> PROGN DEFUN PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-MATHSTATS::Z-TEST-ONE-SAMPLE-INTERNAL
;                          (CL-MATHSTATS::DATA CL-MATHSTATS::TAILS
;                                              &OPTIONAL
;                                              (CL-MATHSTATS::H0-MEAN 0)
;                                              (CL-MATHSTATS::H0-STD-DEV 1)
;                                              &REST
;                                              CL-MATHSTATS::STANDARD-ARGS
;                                              &KEY
;                                              CL-MATHSTATS::START
;                                              CL-MATHSTATS::END
;                                              CL-MATHSTATS::KEY)
;                          (DECLARE
;                           (IGNORE CL-MATHSTATS::START
;                                   CL-MATHSTATS::END
;                                   CL-MATHSTATS::KEY
;                                   CL-MATHSTATS::TAILS)
;                           (VALUES CL-MATHSTATS::Z-STATISTIC
;                                   CL-MATHSTATS::SIGNIFICANCE))
;                          (BLOCK CL-MATHSTATS::Z-TEST-ONE-SAMPLE-INTERNAL
;                            (LET ((CL-MATHSTATS::N #))
;                              (WHEN (ZEROP CL-MATHSTATS::N)
;                                (ERROR 'CL-MATHSTATS::NO-DATA))
;                              (LET (# #)
;                                (WHEN # #)
;                                (LET* #
;                                  #)))))
; 
; caught STYLE-WARNING:
;   undefined type: CL-MATHSTATS::Z-STATISTIC

; 
; caught STYLE-WARNING:
;   2 more uses of undefined type CL-MATHSTATS::Z-STATISTIC

; 
; caught STYLE-WARNING:
;   These functions are undefined:
;     METABANG.UTILITIES::ALLOCATE-EKSL-LOCK METABANG.UTILITIES:DEALLOCATE METABANG.UTILITIES::DEBUGGING-P-FN METABANG.UTILITIES:DESTROY-THREAD CL-GRAPH::GRAPH-SEARCH METABANG.CL-CONTAINERS:MAKE-ITERATOR METABANG.UTILITIES::MAPPEND METABANG.UTILITIES:NYI METABANG.UTILITIES:PUSH-END METABANG.CL-CONTAINERS::READ-CONTAINER-ELEMENT METABANG.UTILITIES:THREAD-WAIT

; 
; caught STYLE-WARNING:
;   These types are undefined:
;     CL-MATHSTATS::ANOVA-TABLE CL-MATHSTATS::BETAS CL-MATHSTATS::CHI-SQUARE CL-MATHSTATS::CHI2 CL-MATHSTATS::COEFFICIENTS CL-MATHSTATS::COMPATIBILITY-VALUE CL-MATHSTATS::CONTIGENCY-TABLE CL-MATHSTATS::CONTINGENCY-TABLE COUNT CL-MATHSTATS::D CL-MATHSTATS::DETERMINATION CL-MATHSTATS::DOF METABANG.UTILITIES:ELEMENT CL-MATHSTATS::F CL-MATHSTATS::FIRST-QUARTILE CL-MATHSTATS::G-SCORE CL-MATHSTATS::G-SIGNIFICANCE CL-MATHSTATS::INTERCEPT LENGTH CL-MATHSTATS::LOWER CL-MATHSTATS::MSE-REG CL-MATHSTATS::MSE-RES CL-MATHSTATS::NUMBER-OF-OCCURRENCES CL-MATHSTATS::P-HAT CL-MATHSTATS::P-VALUE CL-MATHSTATS::R-LIST CL-MATHSTATS::R-SQUARE CL-MATHSTATS::SAMPLE-ERROR CL-MATHSTATS::SLOPE CL-MATHSTATS::SS-PERCENT-LIST CL-MATHSTATS::SS-REG CL-MATHSTATS::SS-REG-LIST CL-MATHSTATS::SS-RES CL-MATHSTATS::STD-ERR-INTERCEPT CL-MATHSTATS::STD-ERR-SLOPE CL-MATHSTATS::STD-ERROR CL-MATHSTATS::T-BS CL-MATHSTATS::T-STATISTIC CL-MATHSTATS::TABLE CL-MATHSTATS::THIRD-QUARTILE CL-MATHSTATS::UPPER CL-MATHSTATS::V1-VALUES CL-MATHSTATS::V2-VALUES CL-MATHSTATS::Z-STATISTIC
; 
; compilation unit finished
;   caught 195 STYLE-WARNING conditions
;   printed 43 notes
*