home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / applications / xlispstat / manual / techreport.ps (.txt) < prev    next >
PageSetter Document  |  1990-10-11  |  232KB  |  1,751 lines
  1. PageSetter II (V1.0)
  2. (CG)Courier
  3. (CG)Symbol
  4. (CG)CenturySchlbk
  5. Green
  6. VYellow
  7. Magenta
  8. wwwwpp
  9.  techreport.ps
  10. No Author
  11. !\n\B\ff<(CG)Times>\fs<36>\jc\ll<2>\ps<100>\t<0>\FpXLISP-STAT \b\fs<12>
  12. \fs<24>A Statistical Environment Based on
  13. the XLISP Language\fs<12>
  14.  \fs<16>(Version 2.0)
  15. Luke Tierney 
  16. University of Minnesota
  17. School of Statistics
  18. Technical Report Number 528
  19. July 1989\fs<12>\jl
  20. l{PPAG
  21. oOPBOX
  22. }\n\B\ff<(CG)Times>\fs<14>\jf\ll<2>\ps<100>\t<0>\FpContents\b\fs<12>
  23. \sPreface\s\s\s\s\s\s\s\s\s\s\s\s  3
  24.  \T\T1\s\BStarting and Finishing\s\s\s\s\s\s\s\s\s \b 6
  25. \T\T2\s\BIntroduction to Basics\b\s\s\s\s\s\s\s\s\s  8
  26. \s2.1 Data\s\s\s\s\s\s\s\s\s\s\s  8
  27. \s2.2 The Listener and the Evaluator\s\s\s\s\s\s\s\s  8
  28. \T\T3\s\BElementary Statistical Operations\b\s\s\s\s\s\s\s\s11
  29. \s3.1 First Steps\s\s\s\s\s\s\s\s\s\s\s11
  30. \s3.2 Summary Statistics and Plots\s\s\s\s\s\s\s\s12
  31. \s3.3 Two Dimensional Plots\s\s\s\s\s\s\s\s\s16
  32. \s3.4 Plotting Functions\s\s\s\s\s\s\s\s\s\s19
  33. \T\T4\s\BMore on Generating and Modifying Data\b\s\s\s\s\s\s\s20
  34. \s4.1 Generating Random Data\s\s\s\s\s\s\s\s\s20
  35. \s4.2 Generating Systematic Data\s\s\s\s\s\s\s\s20
  36. \s4.3 Forming Subsets and Deleting Cases\s\s\s\s\s\s\s21
  37. \s4.4 Combining Several Lists\s\s\s\s\s\s\s\s\s22
  38. \s4.5 Modifying Data\s\s\s\s\s\s\s\s\s\s22
  39. \T\T5\s\BSome Useful Shortcuts\b\s\s\s\s\s\s\s\s\s24
  40. \s5.1 Getting Help\s\s\s\s\s\s\s\s\s\s24
  41. \s5.2 Listing and Undefining Variables\s\s\s\s\s\s\s\s26
  42. \s5.3 More on the XLISP-STAT Listener\s\s\s\s\s\s\s26
  43. \s5.4 Loading Files\s\s\s\s\s\s\s\s\s\s28
  44. \s5.5 Saving your Work\s\s\s\s\s\s\s\s\s\s28
  45. \s5.6 The XLISP-STAT Editor\s\s\s\s\s\s\s\s\s29
  46. \s5.7 Reading Data Files\s\s\s\s\s\s\s\s\s29
  47. \s5.8 User Initialization File\s\s\s\s\s\s\s\s\s29
  48. \T\T6\s\BMore Elaborate Plots\b\s\s\s\s\s\s\s\s\s30
  49. \s6.1 Spinning Plots\s\s\s\s\s\s\s\s\s\s30
  50. \s6.2 Scatterplot Matrices\s\s\s\s\s\s\s\s\s32
  51. \s6.3 Interacting with Individual Plots\s\s\s\s\s\s\s\s35
  52. \s6.4 Linked Plots\s\s\s\s\s\s\s\s\s\s35
  53. \s6.5 Modifying a Scatter Plot\s\s\s\s\s\s\s\s\s36
  54. \s6.6 Dynamic Simulations\s\s\s\s\s\s\s\s\s39
  55. \T\T7\s\BRegression\s\s\s\s\s\s\s\s\s\s\s\b42
  56. \T\T8\s\BDefining Your Own Functions and Methods\b\s\s\s\s\s\s47
  57. \s8.1 Defining Functions\s\s\s\s\s\s\s\s\s47
  58. \s8.2 Anonymous Functions\s\s\s\s\s\s\s\s\s48
  59. \s8.3 Some Dynamic Simulations\s\s\s\s\s\s\s\s48
  60. \s8.4 Defining Methods\s\s\s\s\s\s\s\s\s\s51
  61. \s8.5 Plot Methods\s\s\s\s\s\s\s\s\s\s52
  62. \B\T\b\T9\B\sMatrices and Arrays\b\s\s\s\s\s\s\s\s\s\s53
  63. \T10\s\BNonlinear Regression\b\s\s\s\s\s\s\s\s\s54
  64. \T11\s\BOne Way ANOVA\b\s\s\s\s\s\s\s\s\s\s57
  65. \T12\s\BMaximization and Maximum Likelihood Estimation\b\s\s\s\s\s58
  66. \T13\s\BApproximate Bayesian Computations\b\s\s\s\s\s\s\s61
  67. \TA\s\BXLISP-STAT on UNIX Systems\b\s\s\s\s\s\s\s\s68
  68. \sA.1 XLISP-STAT Under the \IX11\i Window System\s\s\s\s\s\s68
  69. \s\M\MA.1.1 More Advanced \IX11\i Features\s\s\s\s\s\s\s69
  70. \sA.2 XLISP-STAT Under the \ISunView\i Window System\s\s\s\s\s69
  71. \sA.3 Running UNIX Commands from XLISP-STAT\s\s\s\s\s\s70
  72. \sA.4 Dynamic Loading and Foreign Function Calling\s\s\s\s\s70
  73. \TB\sGraphical Interface Tools\b\s\s\s\s\s\s\s\s\s72
  74. \sB.1 Menus\s\s\s\s\s\s\s\s\s\s\s72
  75. \sB.2 Dialogs\s\s\s\s\s\s\s\s\s\s\s73
  76. \s       B.2.1 Modal Dialogs\s\s\s\s\s\s\s\s\s73
  77. \s       B.2.2 Modeless Dialogs\s\s\s\s\s\s\s\s\s74
  78. C\s\BSelected Listing of XLISP-STAT Functions\b\s\s\s\s\s\s75
  79. \sC.1 Arithmetic and Logical Functions\s\s\s\s\s\s\s75
  80. \sC.2 Constructing and Modifying Compound Data and Variables\s\s\s\s77
  81. \sC.3 Basic Statistical Functions\s\s\s\s\s\s\s\s78
  82. \sC.4 Plotting Functions\s\s\s\s\s\s\s\s\s82
  83. \sC.5 Object Methods\s\s\s\s\s\s\s\s\s\s83
  84. \s       C.5.1 Regression Methods\s\s\s\s\s\s\s\s83
  85. \s       C.5.2 General Plot Methods\s\s\s\s\s\s\s\s85
  86. \s       C.5.3 Histogram Methods\s\s\s\s\s\s\s\s88
  87. \s       C.5.4 Name List Methods\s\s\s\s\s\s\s\s88
  88. \s       C.5.5 Scatterplot Methods\s\s\s\s\s\s\s\s88
  89. \s       C.5.6 Spin Plot Methods\s\s\s\s\s\s\s\s\s88
  90. \sC.6 Some Useful Array and Linear Algebra Functions\s\s\s\s\s89
  91. \sC.7 System Functions\s\s\s\s\s\s\s\s\s\s92
  92. \sC.8 Some Basic Lisp Functions, Macros and Special Forms\s\s\s\s\s93\B
  93. PPBOX
  94. uPTXT
  95. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp1\.
  96. ]PBOX
  97. bPTXT
  98. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp2\.
  99. \n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\FpPreface\b\fs<12>
  100. XLISP-STAT is a statistical environment built on top of the XLISP programming language. This document is intended to be a tutorial introduction to the basics of XLISP-STAT. It is written primarily for the Apple Macintosh version, but most of the material applies to other versions as well; some points where other versions differ are outlined in an appendix. The first three sections contain the information you will need to do elementary statistical calculations and plotting. The fourth section introduces some additional methods for generating and modifying data. The fifth section describes some additional features of the Macintosh user interface that may be helpful.  The remaining sections deal with more advanced topics, such as interactive plots, regression models, and writing your own functions.  All sections are organized around examples, and most contain some suggested exercises for the reader.
  101. \piThis document is not intended to be a complete manual. However, documentation for many of the commands available is given in the appendix. Brief help messages for these and other commands are available through the interactive help facility described in Section 5.1 below.
  102. XLISP itself is a high level programming language developed by David Betz and made available for unrestricted, non-commercial use. It is a dialect of Lisp, most closely related to the Common Lisp dialect. XLISP also contains some extensions to Lisp to support object-oriented programming. These facilities have been modified in XLISP-STAT to implement the screen menus, plots and regression models. Several excellent books on Common Lisp are available. One example is Winston and Horn  [22]. A book on XLISP itself has recently been published. Unfortunately it is based on XLISP 1.7, which differs significantly from XLISP 2.0, the basis of XLISP-STAT 2.0. 
  103. Documentation on XLISP 2.0 is included in the source code \pndistribution; a copy is available from me. Betz has also written a tutorial introduction to XLISP for BYTE [5]. However, this deals with version 1.2, which again differs significantly from version 2.0.
  104. \piXLISP-STAT was originally developed for the Apple Macintosh. It is now also available for UNIX systems using the X11 window system, for Sun workstations under the SunVIew window system, and, with only rudimentary graphics, for generic 4.[23]BSD UNIX  systems. The Macintosh version of XLISP-STAT was developed and compiled using the Lightspeed C compiler from Think Technologies, Inc. The Macintosh user interface is based on Paul DuBois' TransSkel and TransEdit libraries. Some of the linear algebra and probability functions are based on code given in Press, Flannery, Teukolsky and Vetterling [14]. Regression computations are carried out using the sweep algorithm as described in Weisberg [21].
  105. This tutorial has borrowed several ideas from Gary Oehlert's \IMacAnova User's Guide\i [13]. Many of the on-line help entries have been adopted directly or with minor modifications from the \IKyoto Common Lisp System\i. Most of the examples used in this tutorial have been taken from Devore and Peck [11]. Many of the functions added to XLISP-STAT were motivated by similar functions in the \IS\i statistical environment [2,3].
  106. The present version of XLISP-STAT 2.0 seems to run fairly comfortably on a Mac II or Mac Plus with 2MB of memory, but is a bit cramped with only 1MB. It will not run in less than 1Mb of memory. The program will occasionally bomb with an ID=28 if it gets into a recursion that is too deep for the Macintosh stack to handle. On a 1MB Mac it may also bomb with an ID=15 if too much memory has been used for the segment loader to be able to bring in a required code segment.\pn
  107. \piDevelopment of XLISP-STAT was supported in part by grants of an Apple Macintosh Plus computer and hard disk and a Macintosh II computer from the MinneMac Project at the University of Minnesota, by a single \pnquarter leave granted to the author by the University of Minnesota, by grant DMS-8705646 from the National Science Foundation, and by a research contract with Bell Communications Research..
  108. \B\fs<14>Using this Tutorial\b\fs<12>
  109. The best way to learn about a new computer program is usually to use it. You will get most out of this tutorial if you read it at your computer and work through the examples yourself. To make this easier the named data sets used in this tutorial have been stored on the file \B\ff<(CG)Courier>tutorial.lsp\b\ff<(CG)Times> in the \BData\b folder of the Macintosh distribution  disk. To read in this file select the \BLoad\b item on the \BFile\b menu. This will bring up an \BOpen File\b dialog window.  Use this dialog to open the \BData\b folder on the distribution disk. Now select the file \B\ff<(CG)Courier>tutorial.lsp\b\ff<(CG)Times> and press the \BOpen\b button. The file will be loaded and some variables will be defined for you.\SP1\Sp
  110. \B\fs<14>Why XLISP-STAT Exists\b\fs<12>
  111. There are three primary reasons behind my decision to produce the XLISP-STAT environment. The first is to provide a vehicle for experimenting with dynamic graphics and for using dynamic graphics in instruction.  Second, I wanted to be able to experiment with an environment supporting functional data, such as mean functions in nonlinear regression models and prior density and likelihood functions in Bayesian analyses. Finally, I was interested in exploring the use of object oriented programming ideas for building and analyzing statistical models. I will discuss each of these points in a little more detail in the following paragraphs.
  112. \piThe development of high resolution graphical computer displays has made it possible to consider the use of dynamic graphics for understanding higher-dimensional structure. One of the earliest examples is the real time rotation of a three dimensional point cloud on a screen -- an effort to use motion to recover a third dimension from a two dimensional display. Other techniques that have been developed include \Ibrushing\i a scatterplot -- highlighting points in one plot and seeing where the corresponding points fall in other plots. A considerable amount of research has been done in this area, see for example the discussion in Becker and Cleveland [4]. and the papers reproduced in Cleveland and McGill[8]. However most of the software developed to date has been developed on specialized hardware, such as the TTY 5620 terminal or Lisp machines. As a result, very few statisticians have had an opportunity to experiment with dynamic graphics first hand, and still fewer have had access to an environment that would allow them to implement dynamic graphics ideas of their own. Several commercial packages for microcomputers now contain some form of dynamic graphics, but most do not allow users to customize their plots or develop functions for producing specialized plots, such as dynamic residual plots. XLISP-STAT provides at least a partial solution to these problems. It allows the user to modify a scatter plot with Lisp level functions and provides means for modifying the way in which a plot responds to mouse actions. It is also easy to add functions written in C to the program. On the Macintosh this \pnhas to be done by adding to the source code. On some unix systems it is also possible to compile and dynamically load code written in C or FORTRAN.
  113. \piAn integrated environment for statistical calculations and graphics is essential for developing an understanding of the uses of dynamic graphics in statistics and for developing new graphical techniques. Such an environment must essentially be a programming language. Its basic data types must include types that allow groups of numbers - data sets - to be manipulated as entire objects. But in model-based analyses numerical data are only part of the information being used. The remainder is the model itself. Sometimes a model is easily characterized by specifying a set of numbers. A normal linear regression model with \Ii. i. d.\i errors might be described by the number of covariates, the coefficients and the error variance. On the other hand, in many cases it is easier to specify a model by specifying a function. To specify a normal nonlinear regression model, for example, one might specify the mean function. If our language is to allow us to specify this function within the language itself then the language must support a functional data type with full rights: I\pnt has to be possible to define functions that manipulate functions, return functions, apply functions to arguments, etc.. The choice I faced was to define a language from scratch or use an existing language.  Because of the complexity of issues involved in functional programming I decided to use a dialect of a well understood functional language, Lisp. The syntax of Lisp is somewhat unfamiliar to most users of statistical packages, but it is easy to learn and several good tutorials are available in local book stores. I considered the possibility of using Lisp to write a top level interface with a more ``natural'' syntax, but I did not see any way of doing this without complicating access to some of the more powerful features of Lisp or running into some of the pitfalls of functional programming. I therefore decided to retain the basic Lisp top level syntax. To make the manipulation of numerical data sets easier I have redefined the arithmetic operators and basic numerical functions to work on lists and arrays of data.
  114. \piHaving decided to use Lisp as the basis for my environment XLISP was a natural choice for several reasons. It has been placed in the public domain by its author, David Betz. It is small (for a Lisp system), its source code is available in C, and it is easily extensible. Finally, it includes support for object oriented programming. Object oriented programming has received considerable attention in recent years and is particularly natural for use in describing and manipulating graphical objects. It may also be useful for the analysis of statistical data and models. A collection of data and assumptions may be represented as an \Iobject\i. The model object can then be examined and modified by sending it \Imessages\i. Many different kinds of models will answer similar questions, thus fitting naturally into an \Iinheritance structure\i. XLISP-STAT's implementation of linear and nonlinear regression models as \Iobjects\i, with nonlinear regression inheriting many of its\I methods\i from linear regression, is a first, primitive attempt to exploit this programming technique in statistical analysis. 
  115. \B\fs<14>Availability\b\fs<12>
  116. Source code for XLISP-STAT for \IX11, Sun\i, 4.[23]BSD UNIX and Macintosh versions and executables for the Macintosh are available free of charge for non-commercial use. You should, however, be prepared to bear the cost of copying, for example by supplying a disk or tape and a stamped mailing envelope. You can also obtain the source code and Macintosh executables by anonymous \Iftp\i over the internet from \Iumnstat.stat.umn.edu\i (128.101.51.1).
  117. \piA version for the Mac II requiring the MC68881 coprocessor is available as well. This version is compiled to access the coprocessor directly and will therefore not run on a machine without the coprocessor. Numerical computations with this version are about 7 to 10 times faster on a Mac II than without the direct coprocessor acces\pns. 
  118. \B\fs<14>Disclaimer\b\fs<12>
  119. XLISP-STAT is an experimental program. It has not been extensively tested. The University of Minnesota, the School of Statistics, the author of the statistical extensions and the author of XLISP take no responsibility for losses or damages resulting directly or indirectly from the use of this program.
  120. \piXLISP-STAT is an evolving system. Over time new features will be introduced, and existing features that do not work may be changed. Every effort will be made to keep XLISP-STAT consistent with the information in this tutorial, but if this is not possible the help information should give accurate information about the current use of a command.\pn
  121. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp3\.
  122. VPBOX
  123. 2PTXT
  124. \n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp__________________________________________________________________________\pi
  125. 1\SpOn a UNIX system you can use the function \B\ff<(CG)Courier>load-data\b\ff<(CG)Times> to load the tutorial data. After starting up XLISP-STAT enter the expression\B\ff<(CG)Courier> (load-data "tutorial")\b\ff<(CG)Times>, followed by a \Ireturn\i.
  126. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp4\.
  127. zDPBOX
  128. |mPBOX
  129. ~RPTXT
  130. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp5\.
  131. \n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp1  Starting and Finishing\b\fs<12>
  132. You should have the program XLISP-STAT on a Macintosh disk. XLISP-STAT needs to have several files available for it to work properly. These files are\SP2\Sp:
  133. \B\ff<(CG)Courier>init.lsp
  134. common.lsp
  135. help.lsp
  136. objects.lsp
  137. menus.lsp
  138. statistics.lsp
  139. dialogs.lsp
  140. graphics.lsp
  141. graphics2.lsp
  142. regression.lsp
  143. xlisp.help\b\ff<(CG)Times>\jf
  144. Before starting XLISP-STAT you should make sure that these files are in the same folder as the XLISP-STAT application.
  145. \piTo start XLISP-STAT double click on its icon. The program will need a little time to start up and read in the files mentioned above. When XLISP-STAT is ready the text in its command window will look something like this\SP3\Sp:
  146. \B\ff<(CG)Courier>XLISP version 2.0, Copyright (c) 1988, by David Betz
  147. XLISP-STAT version 2.0 , Copyright (c) 1988, by Luke Tierney.
  148. Several files will be loaded; this may take a few minutes.
  149. ; loading "init.lsp"
  150. ; loading "common.lsp"
  151. ; loading "help.lsp"
  152. ; loading "objects.lsp"
  153. ; loading "menus.lsp"
  154. ; loading "statistics.lsp"
  155. ; loading "dialogs.lsp"
  156. ; loading "graphics.lsp"
  157. ; loading "graphics2.lsp"
  158. ; loading "regression.lsp"
  159. >\b\ff<(CG)Times>
  160. The final ">" in the window is the XLISP-STAT prompt. Any characters you type while the command window is active will be added to the line after the final prompt. When you hit a return, XLISP-STAT will try to interpret what you have typed and will print a response. For example, if you type a 1 and hit \Ireturn\i then XLISP-STAT will respond by simply printing a 1 on the following line and then giving you a new prompt:
  161. \B\ff<(CG)Courier>
  162. >\b\ff<(CG)Times>
  163. \piIf you type an \Iexpression\i like \B\ff<(CG)Courier>(+ 1 2)\b\ff<(CG)Times>, then XLISP-STAT will print the result of evaluating the expression and give you a new prompt:\pn
  164. \B\ff<(CG)Courier>
  165. > (+ 1 2)
  166. >\b\ff<(CG)Times>
  167. As you have probably guessed, this expression means that the numbers 1 and 2 are to be added together. The next section will give more details on how XLISP-STAT expressions work. In this tutorial I will always show interactions with the program as I have done here: The ">" prompt will appear before lines you should type. XLISP-STAT will supply this prompt when it is ready; you should not type it yourself.
  168. \piNow that you have seen how to start up XLISP-STAT it is a good idea to make sure you know how to get out. As with many Macintosh programs the easiest way to get out is to choose the \BQuit\b command from the \BFile\b menu. You can also use the command key shortcut COMMAND-Q, or you can type the expression\pn
  169. \B\ff<(CG)Courier>
  170. > (exit)\b\ff<(CG)Times>
  171. Any one of these methods should cause the program to exit and return you to the Finder.
  172. v\n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_________________________________________________________________________________\pi
  173. 2\SpThe file \B\ff<(CG)Courier>xlisp.help\b\ff<(CG)Times> is optional. It may be replaced by a reduced file \B\ff<(CG)Courier>xlisp.help.small\b\ff<(CG)Times> or it may be omitted entirely. If it is not present interactive help will \pnnot be available.}:
  174. \SP\pi3\SpOn a Macintosh with limited memory a dialog warning about memory restrictions may be appear at this point. On a Mac II it takes about a minute to load these files; on a Mac Plus or an SE it takes about 3.5 minutes.\fs<12>
  175. ' PBOX
  176. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp6\.
  177. 9\PPAG
  178. :GPBOX
  179. <=PBOX
  180. =5PTXT
  181. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp7\.
  182. OGPPAG
  183. \n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp2   Introduction to Basics\b\fs<12>
  184. Before we can start to use XLISP-STAT for statistical work we need to learn a little about the kind of data XLISP-STAT uses and about how the XLISP-STAT \Ilistener\i and \Ievaluator\i work.
  185. \B2.1 Data\b
  186. XLISP-STAT works with two kinds of data: \Isimple data\i and \Icompound data\i. Simple data are number\ll<-2>s
  187. \B\ff<(CG)Courier>
  188. 1\s\ll<1>\s; an integer
  189. -3.14\s\s; a floating point number
  190. #C(0 \ll<-2>1)\s; a complex number (the imaginary unit)\b\ff<(CG)Times>
  191. logical \ll<-5>v\ll<-2>alues
  192. \B\ff<(CG)Courier>
  193. T\s\ll<1>\s; true
  194. nil\ll<-2>\s\s; false
  195. \b\ff<(CG)Times>
  196. string\ll<1>s (\ll<-2>always enclosed in double quotes)
  197. \B\ff<(CG)Courier>"Thi\ll<-5>s\ll<-2> is a string 1 2 3 4"\b\ff<(CG)Times>
  198. and \ll<-5>sy\ll<-2>mbols (used for naming things; see the following section)
  199. \B\ff<(CG)Courier>
  200. x\ll<1>
  201. this\ll<-2>-is-a-symbol\b\ff<(CG)Times>
  202. Compound data are lists
  203. \B\ff<(CG)Courier>
  204. (this \ll<1>is a list with 7 elements)
  205. (+ 1 2 3)
  206. (sq\ll<-2>rt 2)\b\ff<(CG)Times>
  207. or \ll<-6>vecto\ll<-3>rs
  208. \I\ff<(CG)Courier>
  209. \B\i#(th\ll<1>is is a vector with 7 elements)
  210. #(\ll<-2>1 2 3)\b\ff<(CG)Times>
  211. Higher d\ll<1>imensional arrays are another form of compound data; they will be discussed below in Section 9.
  212. \piAll the examples given above can be typed directly into the command window as they are shown here. The next section describes what XLISP-STAT will do with these expressions.\pn
  213. \B2.2 The Listener and the Evaluator\b
  214. A session with XLISP-STAT basically consists of a conversation between you and the \Ilistener\i. The listener is the window into which you type your commands. When it is ready to receive a command it gives you a prompt. At the prompt you can type in an expression. You can use the mouse or the \Ibackspace\i key to correct any mistakes you make while typing in your expression. When the expression is complete and you type a \Ireturn\i the listener passes the expression on to the \Ievaluator\i. The evaluator evaluates the expression and returns the result to the listener for printing.\SP4\Sp The evaluator it the heart of the system.
  215. \piThe basic rule to remember in trying to understand how the evaluator works is that everything is evaluated. Numbers and strings evaluate to themselves:
  216.  \B\ff<(CG)Courier>\pn
  217. > "Hello"
  218. "Hello"
  219. >\b\ff<(CG)Times>
  220. Lists are more complicated. Suppose you type the list \B\ff<(CG)Courier>(+ 1 2 3)\b\ff<(CG)Times> at the listener. This list has four elements: the symbol \B\ff<(CG)Courier>+\b\ff<(CG)Times> followed by the numbers 1, 2  and 3.  Here is what happens:
  221. \B\ff<(CG)Courier>\ll<-2>
  222. > (+\ll<1> 1 2 3)
  223. >\b\ff<(CG)Times>\ll<-2>
  224. \ll<1>
  225. A list is evaluated as a function application.  The first element is a symbol representing a function, in this case the symbol \B\ff<(CG)Courier>+\b\ff<(CG)Times> representing the addition function. The remaining elements are the arguments.  Thus the list in the example above is interpreted to mean "Apply the function \B\ff<(CG)Courier>+\b\ff<(CG)Times> to the numbers 1, 2 and 3".
  226. \piActually, the arguments to a function are always evaluated before the function is applied. In the previous example the arguments are all numbers and thus evaluate to themselves.  On the other hand, consider\pn
  227. \B\ff<(CG)Courier>\ll<-2>
  228. > (\ll<1>+ (* 2 3) 4)
  229. >\b\ff<(CG)Times>\ll<-2>
  230. \ll<1>
  231. The evaluator has to evaluate the first argument to the function \B\ff<(CG)Courier>+\b\ff<(CG)Times> before it can apply the function.
  232. \piOccasionally you may want to tell the evaluator \Inot\i to evaluate something. For example, suppose we wanted to get the evaluator to simply return the list \B\ff<(CG)Courier>(+ 1 2)\b\ff<(CG)Times> back to us, instead of evaluating it. To do this we need to \Iquote\i our \pnlist:
  233. \B\ff<(CG)Courier>\ll<-2>
  234. > (q\ll<1>uote (+ 1 2))
  235. (+ 1 2)
  236. >\b\ff<(CG)Times>\ll<-2>
  237. \ll<1>
  238. \B\ff<(CG)Courier>quote\b\ff<(CG)Times> is not a function. It does not obey the rules of function evaluation described above: Its argument is not evaluated. \B\ff<(CG)Courier>quote\b\ff<(CG)Times> is called a \Ispecial form\i - special because it has special rules for the treatment of its arguments. There are a few other special forms that we will need; I will introduce them as they are needed.  Together with the basic evaluation rules described here these special forms make up the basics of the LISP language. The special form \B\ff<(CG)Courier>quote\b\ff<(CG)Times> is used so often that a shorthand notation has been developed, a single quote before the expression you want to quote: 
  239. \B\ff<(CG)Courier>\ll<-3>
  240. > '(+ 1 2)     \s; single quote shorthand
  241. \ll<1>
  242. \b\ff<(CG)Times>This is equivalent to \B\ff<(CG)Courier>(quote (+ 1 2))\b\ff<(CG)Times>. Note that there is no matching quote following the expression.
  243. \piBy the way, the semicolon ";" is the LISP comment character. Anything you type after a semicolon up to the next time you hit a return is ignored by the evaluator.\pn
  244. \BExercises
  245. For each of the following expressions try to predict what the evaluator will return. Then type them in, see what happens and try to explain any differences.
  246. \B\ff<(CG)Courier>
  247. \b\ff<(CG)Times>1.\B\ff<(CG)Courier> (+ 3 5 6)
  248. \b\ff<(CG)Times>2.\B\ff<(CG)Courier> (+ (- 1 2) 3)
  249. \b\ff<(CG)Times>3.\B\ff<(CG)Courier> '(+ 3 5 6)
  250. \b\ff<(CG)Times>4.\B\ff<(CG)Courier> '( + (- 1 2) 3)
  251. \b\ff<(CG)Times>5.\B\ff<(CG)Courier> (+ (- (* 2 3) (/ 6 2)) 7)
  252. \b\ff<(CG)Times>6.\B\ff<(CG)Courier> 'x\b\ff<(CG)Times>
  253. Remember, to quit from XLISP-STAT choose \BQuit\b from the \BFile\b menu or type \B\ff<(CG)Courier>(exit)\b\ff<(CG)Times>.
  254. \n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________________________________\pi
  255. 4\SpIt is possible to make a finer distinction. The \Ireader\i  takes a string of characters from the listener and converts it into an expression. The \Ievaluator\i evaluates the expression and the \Iprinter\i converts the result into another string of characters for the listener to print. For simplicity I will use \Ievaluator\i to describe the combination of these functions.\fs<12>\pn
  256. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp8\.
  257. QPPAG
  258. JPTXT
  259. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp9\.
  260. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp10\.
  261. ?PPAG
  262. APBOX
  263. 7|\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp3   Elementary Statistical Operations\b\fs<12>
  264. This section introduces some of the basic graphical and numerical statistical operations that are available in XLISP-STAT.
  265. \B3.1 First Steps\b
  266. Statistical data usually consists of groups of numbers. Devore and Peck [11, Exercise 2.11] describe an experiment in which 22 consumers reported the number of times they had purchased a product during the previous 48 week period. The results are given as a table:
  267. \ll<-2>
  268.     \s\s\s\s0 \ll<1> 2  5  0  3  1  8  0  3   1  1
  269.  \s\s\s\s9\ll<-2>  2  4  0  2  9  3  0  1   9  8
  270. \ll<1>
  271. To examine this data in XLISP-STAT we represent it as a list of numbers using the \B\ff<(CG)Courier>list\b\ff<(CG)Times> function:
  272. \B\ff<(CG)Courier>\ll<-2>
  273. > (\ll<1>list 0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8)
  274. (0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8)
  275. >\b\ff<(CG)Times>\ll<-2>
  276. \ll<1>
  277. Note that the numbers are separated by white space (spaces, tabs or even returns), not commas. 
  278. \piThe \B\ff<(CG)Courier>mean\b\ff<(CG)Times> function can be used to compute the average of a list of numbers. We can combine it with the \B\ff<(CG)Courier>list\b\ff<(CG)Times> function to find the average number of purchases for our sample:\pn
  279. \B\ff<(CG)Courier>\ll<-2>
  280. > (\ll<1>mean (list 0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8))
  281. 3.227273
  282. > \b\ff<(CG)Times>\ll<-2>
  283. \ll<1>
  284. The median of these numbers can be computed as
  285. \B\ff<(CG)Courier>\ll<-2>
  286. > (\ll<1>median (list 0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8))
  287. > \b\ff<(CG)Times>\ll<-2>
  288. \ll<1>
  289. It is of course a nuisance to have to type in the list of 22 numbers every time we want to compute a statistic for the sample. To avoid having to do this I will give this list a name using the \B\ff<(CG)Courier>def\b\ff<(CG)Times> special form\SP5\Sp:
  290. \B\ff<(CG)Courier>\ll<-2>
  291. > \t<-1>(def\ll<1> purchases (list 0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8))\t<0>
  292. PURCHASES
  293. > \b\ff<(CG)Times>\ll<-2>
  294. \ll<1>
  295. Now the symbol \B\ff<(CG)Courier>purchases\b\ff<(CG)Times> has a value associated with it: Its value is our list of 22 numbers. If you give the symbol \B\ff<(CG)Courier>purchases\b\ff<(CG)Times> to the evaluator then it will find the value of this symbol and return that value:
  296. \B\ff<(CG)Courier>\ll<-2>
  297. > purch\ll<1>ases
  298. (0 2 5 0 3 1 8 0 3 1 1 9 2 4 0 2 9 3 0 1 9 8)
  299. > \b\ff<(CG)Times>
  300. We can now easily compute various numerical descriptive statistics for this data set:
  301. \B\ff<(CG)Courier>
  302. > (mean purchases)
  303. 3.227273
  304. > (median purchases)
  305. > (standard-deviation purchases)
  306. 3.279544
  307. > (interquartile-range purchases)
  308. >\b\ff<(CG)Times>
  309. \piXLISP-STAT also supports elementwise arithmetic operations on lists of numbers. For example, we can add 1 to each of the purchases:\pn
  310. \B\ff<(CG)Courier>> (+ 1 purchases)
  311. (1 3 6 1 4 2 9 1 4 2 2 10 3 5 1 3 10 4 1 2 10 9)
  312. >\b\ff<(CG)Times>
  313. and after adding 1 we can compute the natural logarithms of the results:
  314. \B\ff<(CG)Courier>\t<-1>
  315. > (log (+ 1 purchases))
  316. (0 1.098612 1.791759 0 1.386294 0.6931472 2.197225 0 1.386294 0.6931472 
  317. 0.6931472 2.302585 1.098612 1.609438 0 1.098612 2.302585 1.386294 0 
  318. 0.6931472 2.302585 2.197225)
  319. > \b\ff<(CG)Times>\t<0>
  320. \BExercises\b
  321. For each of the following expressions try to predict what the evaluator will return. Then type them in, see what happens and try to explain any differences.
  322. 1. \B\ff<(CG)Courier>(mean (list 1 2 3))\b\ff<(CG)Times>
  323. 2. \B\ff<(CG)Courier>(+ (list 1 2 3) 4)\b\ff<(CG)Times>
  324. 3. \B\ff<(CG)Courier>(* (list 1 2 3) (list 4 5 6))\b\ff<(CG)Times>
  325. 4. \B\ff<(CG)Courier>(+ (list 1 2 3) (list 4 5)\b\ff<(CG)Times>
  326. \B3.2 Summary Statistics and Plots\b
  327. Devore and Peck [11,page 54, Table 10] give precipitation levels recorded during the month of March in the Minneapolis - St. Paul area over a 30 year period. Let's enter these data into XLISP-STAT with the name \B\ff<(CG)Courier>precipitation\b\ff<(CG)Times>:
  328. \B\ff<(CG)Courier>
  329. > (def precipitation
  330.        \s(list .77 1.74 .81 1.20 1.95 1.20 .47 1.43 3.37 2.20 3.30 
  331.              \s\s3.09 1.51 2.10 .52 1.62 1.31 .32 .59 .81 2.81 1.87
  332.              \s\s1.18 1.35 4.75 2.48 .96 1.89 .90 2.05))
  333. PRECIPITATION
  334. >\b\ff<(CG)Times>
  335. \jcFigure 1: Histogram of precipitation levels.\jf
  336. In typing this expression I have hit the \Ireturn\i and \Itab\i keys a few times in order to make the typed expression easier to read. The tab key indents the next line to a reasonable point to make the
  337. expression more readable.
  338. \piThe \B\ff<(CG)Courier>histogram\b\ff<(CG)Times> and \B\ff<(CG)Courier>boxplot\b\ff<(CG)Times> functions can be used to obtain graphical representations of this data set:\pn
  339. \B\ff<(CG)Courier>\ll<-2>
  340. > (histogr\ll<1>am precipitation)
  341. #<Object: 3564170, prototype = HISTOGRAM-PROTO>
  342. > (boxplot precipitation)
  343. #<Object: 3423466, prototype = SCATTERPLOT-PROTO>
  344. >\b\ff<(CG)Times>\ll<-2>
  345. \ll<1>
  346. Each of these commands should cause a window with the appropriate graph to appear on your screen. The windows should look something Figures 1 and 2.
  347. \piNote that as each graph appears it becomes the active window. To get XLISP-STAT to accept further commands you have to click on the XLISP-STAT listener window. You will have to click on the listener window between the two commands shown here.
  348. The two functions return results that are printed something like this:\pn
  349. \ll<-2>
  350. \B\ff<(CG)Courier>#<Object: 3564170, prototype = HISTOGRAM-PROTO>\b\ff<(CG)Times>
  351. \ll<1>
  352. These result will be used later to identify the window containing the plot. For the moment you can ignore them.
  353. \piWhen you have several plot windows open you might want to close the listener window so you can rearrange the plots more easily. You can do this by clicking in the listener window's close box. You can later reopen the listener window by selecting the \BShow XLISP-STAT\b item on the \BCommand\b menu.\pn
  354. \piHere are some numerical summaries:\pn
  355. \B\ff<(CG)Courier>\ll<-2>
  356. > (mea\ll<1>n precipitation)
  357. 1.685
  358. > (median precipitation)
  359. > (standard-deviation precipitation)
  360. 1.0157
  361. > (interquartile-range precipitation)
  362. 1.145
  363. \b\ff<(CG)Times>\jcFigure 2: Boxplot of precipitation levels.\jf
  364.                                   
  365. \piThe distribution of this data set is somewhat skewed to the right. Notice the separation between the mean and the median. You might want to try a few simple transformations to see if you can symmetrize the data. Square root and log transformations can be computed using the expressions \pn
  366. \ll<-2>
  367. \B\ff<(CG)Courier>(sqrt precipitation)\b\ff<(CG)Times>
  368. \ll<1>
  369. \ll<-2>
  370. \B\ff<(CG)Courier>(log precipitation).\b\ff<(CG)Times>
  371. \ll<1>
  372. You should look at plots of the data to see if these transformations do indeed lead to a more symmetric shape. The means and medians of the transformed data are
  373. \B\ff<(CG)Courier>\ll<-2>
  374. > (m\ll<1>ean (sqrt precipitation))
  375. 1.243006
  376. > (median (sqrt precipitation))
  377. 1.212323
  378. > (mean (log precipitation))
  379. 0.3405517
  380. > (median (log precipitation))
  381. 0.384892
  382. > \b\ff<(CG)Times>\ll<-2>
  383. \ll<1>
  384. The boxplot function can also be used to produce parallel boxplots of two or more samples. It will do so if it is given a list of lists as its argument instead of a single list. As an example, let's use this function to compare serum total cholesterol values for samples of rural and urban Guatemalans (see
  385. Devore and Peck [11, page 19, Example 3]:
  386. \jcFigure 3: Parallel box plots of cholesterol levels for urban and rural guatemalans.\jf
  387. \ff<(CG)Courier>
  388. \B> (def urban (list \s184 196 217 284 184 236 189 206 179 170 205 190
  389.                    \s\s\s\s204 330 217 242 222 242 249 241))
  390. URBAN
  391. > (def rural (list \s166 146 144 204 158 143 158 180 223 194 194 175
  392.                    \s\s\s\s171 155 143 145 131 181 148 144 220 129))
  393. RURAL
  394. > \b\ff<(CG)Times>
  395. The parallel boxplot is obtained by
  396. \B\ff<(CG)Courier>
  397. > (boxplot (list urban rural))
  398. #<Object: 3423466, prototype = SCATTERPLOT-PROTO>
  399. > \b\ff<(CG)Times>
  400. and is shown in Figure 3; the urban group is on the left.
  401.                       
  402. \BExercises\b
  403. The following exercises involve examples and problems from Devore and Peck [11]. The data sets are in files in the folder \BData\b on the XLISP-STAT distribution disk and can be read in using the \BLoad\b item in the \BFile\b menu or using the \B\ff<(CG)Courier>load\b\ff<(CG)Times> function (see Section 5.4 below). To use the \BLoad\b item on the \BFile\b menu select this item from the menu. This will bring up an \BOpen File\b dialog window. Use this dialog to open the \BData\b folder on the distribution disk. Now select one of the \B\ff<(CG)Courier>.lsp\b\ff<(CG)Times> files \B\ff<(CG)Courier>(car-prices.lsp\b\ff<(CG)Times> for the first exercise) and press the \BOpen\b button. The file will be loaded and some variables will be defined for you.  Loading file \B\ff<(CG)Courier>car-prices.lsp\b\ff<(CG)Times> will define the single variable \B\ff<(CG)Courier>car-prices\b\ff<(CG)Times>. Loading file \B\ff<(CG)Courier>heating.lsp\b\ff<(CG)Times> will define two variables, \B\ff<(CG)Courier>gas-heat\b\ff<(CG)Times> and \B\ff<(CG)Courier>electric-heat\b\ff<(CG)Times>.\SP6\Sp
  404. \po1. Devore and Peck [11, page 18, Example 2] give advertised prices for a sample of 50 used Japanese subcompact cars.  Obtain some plots and summary statistics for this data. Experiment with some transformations of the data as well. The data set is called car-prices} in the file \B\ff<(CG)Courier>car-prices.lsp\b\ff<(CG)Times>. The prices are given in units of $1000; thus the price 2.39 represents $2390. The data have been sorted by their leading digit.\pn
  405. \po2. In Exercise 2.40 Devore and Peck [11] give heating costs for a sample of apartments heated by gas and a sample of apartments heated by electricity.  Obtain plots and summary statistics for these samples separately and look at a parallel box plot for the two samples. These data sets are called \B\ff<(CG)Courier>gas-heat\b\ff<(CG)Times> and \B\ff<(CG)Courier>electric-heat\b\ff<(CG)Times> in the file\B\ff<(CG)Courier> heating.lsp\b\ff<(CG)Times>.\pn
  406. \B3.3 Two Dimensional Plots\b
  407. Many single samples are actually collected over time. The precipitation data set used above is an example of this kind of data. In some cases it is reasonable to assume that the observations are independent of one another, but in other cases it is not. One way to check the data for some form of serial correlation or trend is to plot the observations against time, or against the order in which they were obtained. I will use the \B\ff<(CG)Courier>plot-points\b\ff<(CG)Times> function to produce a scatterplot of the precipitation data versus time. The \B\ff<(CG)Courier>plot-points\b\ff<(CG)Times> function is called as 
  408. \B\ff<(CG)Courier>\ll<-5>
  409. (plot-points x-variable y-variable)
  410. \b\ff<(CG)Times>\ll<1>
  411. Our \Iy\i-variable will be \B\ff<(CG)Courier>precipitation\b\ff<(CG)Times>, the variable we defined earlier. As our \Ix\i-variable we would like to use a sequence of integers from 1 to 30. We could type these in ourselves, but there is an easier way. The function \B\ff<(CG)Courier>iseq\b\ff<(CG)Times>,  short for \Iinteger-sequence\i, generates a list of consecutive integers between two specified values. The general form for a call to this function is
  412. \B\ff<(CG)Courier>\ll<-5>
  413. (iseq start end).
  414. \b\ff<(CG)Times>\ll<1>
  415. To generate the sequence we need we use
  416. \B\ff<(CG)Courier>\ll<-5>
  417. (iseq 1 30)
  418. \b\ff<(CG)Times>\ll<1>
  419. Thus to generate the scatter plot we type
  420. \B\ff<(CG)Courier>\ll<-5>
  421. > (\ll<-2>plo\ll<1>t-points (iseq 1 30) precipitation)
  422. #<Object: 3423466, prototype = SCATTERPLOT-PROTO>
  423. > \b\ff<(CG)Times>\ll<-5>
  424. \ll<1>
  425. and the result will look like Figure 4. There does not appear to be much of a pattern to the data; an independence assumption may be reasonable.
  426. \piSometimes it is easier to see temporal patterns in a plot if the points are connected by lines. Try the above command with \B\ff<(CG)Courier>plot-points\b\ff<(CG)Times> replaced by \B\ff<(CG)Courier>plot-lines\b\ff<(CG)Times>.\pn
  427. \piThe \B\ff<(CG)Courier>plot-lines\b\ff<(CG)Times> function can also be used to construct graphs of functions. Suppose you would like a plot of sin(\Ix\i) from -\ff<(CG)Symbol>p\ff<(CG)Times> to +\ff<(CG)Symbol>p\ff<(CG)Times>. The constant \ff<(CG)Symbol>p\ff<(CG)Times> is predefined as the variable \B\ff<(CG)Courier>pi\b\ff<(CG)Times>.  You can construct a list of\I n\i equally spaced real numbers between \Ia\i and \Ib\i using the expression\pn
  428. \ll<-2>
  429. \B\ff<(CG)Courier>(rseq a b n)\b\ff<(CG)Times>.
  430. \ll<1>
  431. Thus to draw the plot of sin(\Ix\i) using 50 equally spaced points type
  432. \jcFigure 4: Scatterplot of precipitation levels against time.\jf
  433.                                   
  434. \B\ff<(CG)Courier>\ll<-2>
  435. > (plot-lines\ll<1> (rseq (- pi) pi 50) (sin (rseq (- pi) pi 50)))
  436. #<Object: 3423466, prototype = SCATTERPLOT-PROTO>
  437. > \b\ff<(CG)Times>\ll<-2>
  438. \ll<1>
  439. The plot should look like Figure 5.
  440. \piScatterplots are of course particularly useful for examining the relationship between two numerical observations taken on the same subject. Devore and Peck [11, Exercise 2.33] give data for HC and CO emission recorded for 46 automobiles. The results can be placed in two variables, \B\ff<(CG)Courier>hc\b\ff<(CG)Times> and \B\ff<(CG)Courier>co\b\ff<(CG)Times>, and these variable can then be plotted against one another with the \B\ff<(CG)Courier>plot-points\b\ff<(CG)Times> function:\pn
  441. \B\ff<(CG)Courier>\ll<-2>
  442. > \ll<1>(def hc (list .5 .46 .41 .44 .72 .83 .38 .60 .83 .34 .37 .87 
  443.                 \s\s\s.65 .48 .51 .47 .56 .51 .57 .36 .52 .58 .47 .65 
  444.                 \s\s\s.41 .39 .55 .64 .38 .50 .73 .57 .41 1.02 1.10 .43 
  445.                 \s\s\s.41 .41 .52 .70 .52 .51 .49 .61 .46 .55))
  446. > (def co (list 5.01 8.60 4.95 7.51 14.59 11.53 5.21 9.62 15.13
  447.                 \s\s\s3.95 4.12 19.00 11.20 3.45 4.10 4.74 5.36 5.69
  448.                 \s\s\s6.02 2.03 6.78 6.02 5.22 14.67 4.42 7.24 12.30
  449.                 \s\s\s7.98 4.10 12.10 14.97 5.04 3.38 23.53 22.92 3.81
  450.                 \s\s\s1.85 2.26 4.29 14.93 6.35 5.79 4.62 8.43 3.99 7.47))
  451. > (plot-points hc co)
  452. #<Object: 3423466, prototype = SCATTERPLOT-PROTO>
  453. > \b\ff<(CG)Times>\ll<-2>
  454. \ll<1>
  455. The resulting plot is shown in Figure 6.
  456. \jcFigure 5: A plot of sin(x).
  457. Figure 6: Plot of HC against CO.\jf
  458. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp11\.
  459. \n\B\SP\ff<(CG)Courier>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________________________\pi
  460. 5\Spdef\b\ff<(CG)Times> acts like a special form, rather than a function, since its first argument is not evaluated (otherwise you would have to quote the symbol). Technically \B\ff<(CG)Courier>def\b\ff<(CG)Times> is a macro, not a special form, but I will not worry about this distinction in this document. \B\ff<(CG)Courier>def\b\ff<(CG)Times> is closely related to the standard Lisp special forms \B\ff<(CG)Courier>setf\b\ff<(CG)Times> and \B\ff<(CG)Courier>setq\b\ff<(CG)Times>. The advantage of using \B\ff<(CG)Courier>def\b\ff<(CG)Times> is that it adds your variable name\pn to a list of \B\ff<(CG)Courier>def\b\ff<(CG)Times>'ed variables kept in the global variable \B\ff<(CG)Courier>variables\b\ff<(CG)Times>. If you use \B\ff<(CG)Courier>setf\b\ff<(CG)Times> or \B\ff<(CG)Courier>setq\b\ff<(CG)Times> there is no easy way to find variables you have defined, as opposed to ones that are predefined. \B\ff<(CG)Courier>def\b\ff<(CG)Times> always affects top level symbol bindings, not local bindings. It can not be used in function definitions to change local bindings.\fs<12>
  461. 8]TPPAG
  462. 8byPTXT
  463. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp12\.
  464. 8u=PPAG
  465. 8w.PBOX
  466. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp13\.
  467. 1PBOX
  468. OPTXT
  469. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp14\.
  470. IPBOX
  471. #PTXT
  472. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp15\.
  473. QPBOX
  474. ~PPAG
  475. zPTXT
  476. ~\n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp______________________________________________________________________\pi
  477. 7\SpOn UNIX systems use the function \B\ff<(CG)Courier>load-data\b\ff<(CG)Times>. For example, evaluating the expression \B\ff<(CG)Courier>(load-data "car-prices")\b\ff<(CG)Times> should load the file\B\ff<(CG)Courier> car-prices.lsp\b\ff<(CG)Times>.
  478. 9IkPTXT
  479. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp16\.
  480. 9^aPBOX
  481. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp17\.
  482. 9zxPBOX
  483. 5\n\ff<(CG)Times>\fs<12>\ll<1>\ps<100>\t<0>\Fp18\.
  484. A\n\B\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\FpExercises\b
  485. 1. Draw a graph of the function f(x) = 2x + x\SP2\Sp between -2 and 3.
  486. 2. \poDevore and Peck [11, Exercise 4.2] give the age and CPK concentration, a measure of metabolic activity, recorded for 18 cross country skiers during a relay race. These data are in the variables \B\ff<(CG)Courier>age\b\ff<(CG)Times> and \B\ff<(CG)Courier>cpk\b\ff<(CG)Times> in the file \B\ff<(CG)Courier>metabolism.lsp\b\ff<(CG)Times>. Plot the data and describe any relationship you observe between age and CPK concentration.\pn
  487. \B3.4  Plotting Functions\b
  488. Plotting the sine functions in the previous section was a bit cumbersome. As an alternative we can use the function \B\ff<(CG)Courier>plot-function\b\ff<(CG)Times> to plot a function of one argument over a specified range. We can plot the sine function using the expression
  489. \B\ff<(CG)Courier>
  490. (plot-function (function sin) (- pi) pi)
  491. \b\ff<(CG)Times>
  492. The expression \B\ff<(CG)Courier>(function sin)\b\ff<(CG)Times> is needed to extract the function associated with the symbol \B\ff<(CG)Courier>sin\b\ff<(CG)Times>. Just using \B\ff<(CG)Courier>sin\b\ff<(CG)Times> will not work. The reason is that a symbol in Lisp can have both a \Ivalue\i, perhaps set using \B\ff<(CG)Courier>def\b\ff<(CG)Times>, and a \Ifunction definition\i at the same time.\SP7\Sp This may seem a bit cumbersome at first, but it has one great advantage: Typing an innocent expression like
  493. \B\ff<(CG)Courier>
  494. (def list '(2 3 4))\b\ff<(CG)Times>
  495. will not destroy the\B\ff<(CG)Courier> list\b\ff<(CG)Times> function. 
  496. Extracting a function definition from a symbol is done almost as often as quoting an expression, so again a simple shorthand notation is available. The expression
  497. \B\ff<(CG)Courier>#'sin
  498. \b\ff<(CG)Times>is equivalent to the expression \B\ff<(CG)Courier>(function sin).\b\ff<(CG)Times>The short form \B\ff<(CG)Courier>#'\b\ff<(CG)Times> is usually pronounc-ed \Isharp-quote\i. Using this abbreviation the expression for producing the sine plot can be written as 
  499. \B\ff<(CG)Courier>
  500. (plot-function #'sin (- pi) pi)
  501. a\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp \SP\fs<10>\pi7\SpAs an aside, a Lisp symbol can be thought of as a "thing" with four cells. These cells contain the symbol's print name, its value, its function definition, and its property list.  Lisp symbols are thus much more like physical entities than variable identifiers in FORTRAN or C.\pn
  502. 5\n\ff<(CG)Times>\fs<12>\ll<2>\ps<100>\t<0>\Fp19\.
  503. (y\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp4   More\ll<4> on Generating and Modifying Data\b\fs<12>
  504. \ll<1>
  505. This section briefly summarizes some techniques for generating random and systematic data.
  506. \B4.1  Generating Random Data\b
  507. XLISP-STAT has several functions for generating pseudo-random numbers. For example, the expression
  508. \ll<-2>
  509. \B\ff<(CG)Courier>(uniform-rand 50)\b\ff<(CG)Times>
  510. \ll<1>
  511. will generate a list of 50 independent uniform random variables. The functions \B\ff<(CG)Courier>normal-rand\b\ff<(CG)Times> and \B\ff<(CG)Courier>cauchy-rand\b\ff<(CG)Times> work similarly. Other generating functions require additional arguments to specify distribution parameters. Here is a list of the functions available for dealing with probability distributions:\ll<-2>
  512. \B\ff<(CG)Courier>\pinorm\ll<1>al-cdf \snormal-quant \snormal-rand \snormal-dens
  513. cauchy-cdf \scauchy-quant \scauchy-rand \scauchy-dens
  514. beta-cdf \s\sbeta-quant \sbeta-rand \s\sbeta-dens
  515. gamma-cdf \s\sgamma-quant \sgamma-rand \sgamma-dens
  516. chisq-cdf \s\schisq-quant \schisq-rand \schisq-dens
  517. t-cdf \s\st-quant \s\st-rand \s\st-dens
  518. f-cdf\ll<-2> \s\sf-quant \s\sf-rand \s\sf-dens\b\ff<(CG)Times>\pn
  519. \B\ff<(CG)Courier>\pibinom\ll<1>ial-cdf \sbinomial-quant binomial-rand \sbinomial-pmf
  520. poisson\ll<-2>-cdf \spoisson-quant \spoisson-rand \spoisson-pmf
  521. bivnorm-cdf\b\ff<(CG)Times>\pn
  522. More informatio\ll<1>n on the required arguments is given in the appendix in Section C.3. The discrete quantile functions \B\ff<(CG)Courier>binomial-quant\b\ff<(CG)Times> and \B\ff<(CG)Courier>poisson-quant\b\ff<(CG)Times> return values of a left continuous inverse of the cdf. The pmf's for these distributions are only defined for integer arguments. The quantile functions and random variable generators for the beta, gamma, \ff<(CG)Symbol>c\SP\ff<(CG)Times>2\Sp, t and F distributions are presently calculated by inverting the cdf and may be a bit slow. 
  523. \piThe state of the internal random number generator can be ``randomly'' reseeded, and the current value of the generator state can be saved. The mechanism used is the standard Common Lisp mechanism. The current random state is held in the variable \B*\ff<(CG)Courier>random-state*\b\ff<(CG)Times>. The function \B\ff<(CG)Courier>make-random-state\b\ff<(CG)Times> can be used to set and save the state. It takes an optional argument. If the argument is \B\ff<(CG)Courier>NIL\b\ff<(CG)Times> or omitted \B\ff<(CG)Courier>make-random-state\b\ff<(CG)Times>  returns a copy of the current value of \B\ff<(CG)Courier>*random-state*\b\ff<(CG)Times>. If the argument is a state object a copy of it is  returned. If the argument is\B\ff<(CG)Courier> t\b\ff<(CG)Times> a new, "randomly" initialized state object is produced and returned.\SP8\Sp\pn
  524. \B4.2  Generating Systematic Data\b
  525. We have already used the functions \B\ff<(CG)Courier>iseq\b\ff<(CG)Times> and \B\ff<(CG)Courier>rseq\b\ff<(CG)Times> to generate equally spaced sequences of integers and real numbers. The function \B\ff<(CG)Courier>repeat\b\ff<(CG)Times> is useful for generating sequences with a particular pattern. The general form of  a call to \B\ff<(CG)Courier>repeat\b\ff<(CG)Times> is
  526. \B\ff<(CG)Courier>(repeat list pattern)\b\ff<(CG)Times>
  527. \B\ff<(CG)Courier>pattern\b\ff<(CG)Times> must be either a single number or a list of numbers of the same length as \B\ff<(CG)Courier>list\b\ff<(CG)Times>. If \B\ff<(CG)Courier>pattern\b\ff<(CG)Times> is a single number then \B\ff<(CG)Courier>repeat\b\ff<(CG)Times> simply repeats \B\ff<(CG)Courier>list pattern\b\ff<(CG)Times> times. For example
  528. \B\ff<(CG)Courier>> (repeat (list 1 2 3) 2)
  529. (1 2 3 1 2 3)\b\ff<(CG)Times>\ll<-2>
  530. \ll<1>
  531. If \B\ff<(CG)Courier>pattern\b\ff<(CG)Times> is a list then each element of \B\ff<(CG)Courier>list\b\ff<(CG)Times> is repeated the number of times indicated by the  corresponding element of \B\ff<(CG)Courier>pattern\b\ff<(CG)Times>. For example
  532. \ll<-2>
  533. \B\ff<(CG)Courier>> (repeat (list 1 2 3) (list 3 \ll<1>2 1))
  534. (1 1 1 2 2 3)\b\ff<(CG)Times>\ll<-2>
  535. \ll<1>
  536. In Section 6.2 below I generate the variables \B\ff<(CG)Courier>density\b\ff<(CG)Times> and \B\ff<(CG)Courier>variety\b\ff<(CG)Times> by typing them in directly. Using the \B\ff<(CG)Courier>repeat\b\ff<(CG)Times> function we could have generated them like this:
  537. \ll<-2>
  538. \B\ff<(CG)Courier>(def densit\ll<1>y (repeat (repeat (list 1 2 3 4) (list 3 3 3 3)) 3))
  539. (def varie\ll<-3>ty (repeat (list 1 2 3) (list 12 12 12)))\b\ff<(CG)Times>
  540. \ll<1>
  541. \B4.3  Forming Subsets and Deleting Cases\b
  542. The \B\ff<(CG)Courier>select\b\ff<(CG)Times> function allows you to select a single element or a group of elements from a list or vector. For example, if we define \B\ff<(CG)Courier>x\b\ff<(CG)Times> by
  543. \ll<-2>
  544. \B\ff<(CG)Courier>(def x (list 3 7 5 9 12 3 14 2))\b\ff<(CG)Times>
  545. \ll<1>
  546. then \B\ff<(CG)Courier>(select x i)\b\ff<(CG)Times> will return the\I i\i-th element of \B\ff<(CG)Courier>x\b\ff<(CG)Times>. LISP, like the language C but in contrast to Fortran, numbers elements of list and vectors starting at zero. Thus the indices for the elements of \B\ff<(CG)Courier>x\b\ff<(CG)Times> are 0, 1, 2, 3, 4, 5, 6, 7. So
  547. \ll<-1>
  548. \B\ff<(CG)Courier>> (select x\ll<1> 0)
  549. > (select x 2)
  550. 5\b\ff<(CG)Times>\ll<-5>
  551. \ll<1>
  552. To get a group of elements at once we can use a list of indices instead of a single index:
  553. \ll<-2>
  554. \B\ff<(CG)Courier>> (sele\ll<1>ct x (list 0 2))
  555. (3 5)\b\ff<(CG)Times>\ll<-2>
  556. \ll<1>
  557. \piIf you want to select all elements of x except element 2 you can use the expression \pn
  558. \ll<-2>
  559. \B\ff<(CG)Courier>(remove 2 (iseq 0 7))\b\ff<(CG)Times>
  560. \ll<1>
  561. as the second argument to the function select:
  562. \ll<-2>
  563. \B\ff<(CG)Courier>> (remove 2 (iseq 0 7))\ll<1>
  564. (0 1 3 4 5 6 7)
  565. > (select x (remove 2 (iseq 0 7)))
  566. (3 7 9 12 3 14 2)\b\ff<(CG)Times>\ll<-2>
  567. \ll<1>
  568. Another approach is to use the logical function /= (meaning not equal) to tell you which indices are not equal to 2. The function \B\ff<(CG)Courier>which\b\ff<(CG)Times> can then be used to return a list of all the indices for which the elements of its argument are not \B\ff<(CG)Courier>NIL\b\ff<(CG)Times>:
  569. \ll<-2>
  570. \B\ff<(CG)Courier>> (/= 2 (iseq 0 7))\ll<1>
  571. (T T NIL T T T T T)
  572. > (which (/= 2 (iseq 0 7)))
  573. (0 1 3 4 5 6 7)
  574. > (select x (which (/= 2 (iseq 0 7))))
  575. (3 7 9 12 3 14 2)\b\ff<(CG)Times>
  576. This approach is a little more cumbersome for deleting a single element, but it is more general. The expression \B\ff<(CG)Courier>(select x (which (< 3 x)))\b\ff<(CG)Times>, for example, returns all elements in \B\ff<(CG)Courier>x\b\ff<(CG)Times> that are greater than 3:\ll<-2>
  577. \B\ff<(CG)Courier>> (select \ll<1>x (which (< 3 x)))
  578. (7 5 9 12 14)\b\ff<(CG)Times>
  579. \B4.4  Combining Several Lists\b
  580. At times you may want to combine several short lists into a single longer list. This can be done using the \B\ff<(CG)Courier>append\b\ff<(CG)Times> function. For example, if you have three variables \B\ff<(CG)Courier>x\b\ff<(CG)Times>, \B\ff<(CG)Courier>y\b\ff<(CG)Times> and \B\ff<(CG)Courier>z\b\ff<(CG)Times> constructed by the expressions\ll<-2>
  581. \B\ff<(CG)Courier>(def x (l\ll<1>ist 1 2 3))
  582. (def y (list 4))
  583. (def z (li\ll<-2>st 5 6 7 8))\b\ff<(CG)Times>
  584. then the expression
  585. \B\ff<(CG)Courier>(append x y z)\b\ff<(CG)Times>
  586. will return the list 
  587. \B\ff<(CG)Courier>(1 2 3 4 5 6\ll<1> 7 8).\b\ff<(CG)Times>
  588. \B4.5  Modifying Data\b
  589. So far when I have asked you to type in a list of numbers I have been assuming that you will type the list correctly. If you made an error you had to retype the entire\B\ff<(CG)Courier> def\b\ff<(CG)Times> expression. Since you can use cut--and--paste this is really not too serious. However it would be nice to be able to replace the values in a list after you have typed it in. The \B\ff<(CG)Courier>setf\b\ff<(CG)Times> special form is used for this. Suppose you would like to chang\ll<-2>e the 12 in the list \B\ff<(CG)Courier>x\b\ff<(CG)Times> used in the Section 4.3 to 11. The expression
  590. \ll<1>
  591. \B\ff<(CG)Courier>(setf (se\t<1>\ll<-2>lect x 4) 11)\b\ff<(CG)Times>
  592. will m\ll<-5>ake thi\t<0>\ll<-2>s replacement:
  593. \B\ff<(CG)Courier>> (s\ll<1>etf (select x 4) 11)
  594. (3 7 5 \ll<-2>9 11 3 14 2)\b\ff<(CG)Times>
  595. \piTh\ll<1>e general form of \B\ff<(CG)Courier>setf\b\ff<(CG)Times> is\pn
  596. \ll<-2>
  597. \B\ff<(CG)Courier>(setf form value)\b\ff<(CG)Times>
  598. where \B\ff<(CG)Courier>form\b\ff<(CG)Times> i\ll<1>s the expression you would use to select a single element or a group of elements from \B\ff<(CG)Courier>x\b\ff<(CG)Times> and \B\ff<(CG)Courier>value\b\ff<(CG)Times> is the value you would like that element to have, or the list of the values for the elements in the group.  Thus the expression
  599. \ll<-2>
  600. \B\ff<(CG)Courier>(setf (select x (list 0 2)) (list 15 16))\b\ff<(CG)Times>
  601. \ll<1>
  602. changes the values \ll<-2>of elements 0 and 2 to 15 and 16:
  603. \B\ff<(CG)Courier>> (setf (sele\ll<1>ct x (list 0 2)) (list 15 16))
  604. (15 16)
  605. (15 7 16 9 11 3 14 2)\b\ff<(CG)Times>
  606. \piA note of caution is needed here. Lisp symbols are merely labels for different items. When you assign a name to an item with the \B\ff<(CG)Courier>def\b\ff<(CG)Times> command you are not producing a new item. Thus
  607. \B\ff<(CG)Courier>(def x (list 1 2 3 4))
  608. (def y x)\b\ff<(CG)Times>
  609. means that \B\ff<(CG)Courier>x\b\ff<(CG)Times> and \B\ff<(CG)Courier>y\b\ff<(CG)Times> are two different names for the same thing. As a result, if we change an element of (the item referred to by) \B\ff<(CG)Courier>x\b\ff<(CG)Times> with \B\ff<(CG)Courier>setf\b\ff<(CG)Times> then we are also changing the element of (the item referred to by) \B\ff<(CG)Courier>y\b\ff<(CG)Times>, since both \B\ff<(CG)Courier>x\b\ff<(CG)Times> and\B\ff<(CG)Courier> y\b\ff<(CG)Times> refer to the same item. If you want to make a copy of\B\ff<(CG)Courier> x\b\ff<(CG)Times> and store it in \B\ff<(CG)Courier>y\b\ff<(CG)Times> before you make changes to \B\ff<(CG)Courier>x\b\ff<(CG)Times> then you must do so explicitly using, say, the \B\ff<(CG)Courier>copy-list\b\ff<(CG)Times> function. The expression
  610. \B\ff<(CG)Courier>(def y (copy-list x))\b\ff<(CG)Times>
  611. will make a copy of \B\ff<(CG)Courier>x\b\ff<(CG)Times> and set the value of\B \ff<(CG)Courier>y\b\ff<(CG)Times> to that copy. Now \B\ff<(CG)Courier>x\b\ff<(CG)Times> and \B\ff<(CG)Courier>y\b\ff<(CG)Times> refer to different objects and changes to \B\ff<(CG)Courier>x\b\ff<(CG)Times> will not affect \B\ff<(CG)Courier>y\b\ff<(CG)Times>.
  612. /PBOX
  613. VPTXT
  614. v\n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_______________________________________________\pi
  615. 8\SpThe generator used is Marsaglia's portable generator from  the \ICore Math Libraries\i distributed by the National Bureau of Standards. A state object is a vector containing the state information of the generator. "Random" reseeding occurs off the system clock.
  616. 8\n\ff<(CG)Times>\fs<12>\jf\ll<4>\ps<100>\t<0>\Fp20\.
  617. ;PPAG
  618. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-5>\ps<100>\t<0>\Fp21\.
  619. K-iPPAG
  620. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp22\.
  621. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp23\.
  622. KWwPPAG
  623. Jt\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp5   Some Useful Shortcuts\b\fs<12>
  624. This section describes some additional features of XLISP-STAT that you may find useful.
  625. \B5.1  Getting Help\b
  626. On line help is available for many of the functions in XLISP-STAT\SP9\Sp  As an example, here is how you would get help for the function \B\ff<(CG)Courier>median\b\ff<(CG)Times>:
  627. \B\ff<(CG)Courier>> (help 'median)
  628. MEDIAN\s\s\s\s\s\s\s\s\s[function-doc]
  629. Args: (x)
  630. Returns the median of the elements of X.
  631. > \b\ff<(CG)Times>
  632. Note the quote in front of \B\ff<(CG)Courier>median\b\ff<(CG)Times>. \B\ff<(CG)Courier>help\b\ff<(CG)Times> is itself a function, and its argument is the symbol representing the function \B\ff<(CG)Courier>median\b\ff<(CG)Times>. To make sure \B\ff<(CG)Courier>help\b\ff<(CG)Times> receives the symbol, not the value of the symbol, you need to quote the symbol.
  633. \piIf you are not sure about the name of a function you may still be able to get some help. Suppose you want to find out about functions related to the normal distribution. Most such functions will have "norm" as part of their name. The expression\pn
  634. \B\ff<(CG)Courier>(help* 'norm)\b\ff<(CG)Times>
  635. will print the help information for all symbols whose names contain the string "norm":\ff<(CG)Courier>> 
  636. \B\t<-1>>(help* 'norm)
  637. ---------------------------------------------------------------------------
  638. Sorry, no help available on NORM
  639. ---------------------------------------------------------------------------
  640. Sorry, no help available on NORM-2
  641. ---------------------------------------------------------------------------
  642. Sorry, no help available on NORMAL
  643. ---------------------------------------------------------------------------
  644. NORMAL-CDF\s\s\s\s\s\s\s\s\s\s[function-doc]
  645. Args: (x)\t<0>
  646. \t<-2>Returns the value of the standard normal distribution function at X. Vectorized.\t<-1>
  647. ---------------------------------------------------------------------------
  648. NORMAL-DENS\s \s\s\s\s\s\s\s\s\s[function-doc]
  649. Args: (x)
  650. Returns the density at X of the standard normal distribution. Vectorized.
  651. ---------------------------------------------------------------------------
  652. NORMAL-QUANT\s\s\s\s\s\s\s\s\s[function-doc]
  653. Args (p)
  654. Returns the P-th quantile of the standard normal distribution. Vectorized.\t<0>
  655. \t<-1>-----------------------------------------------------
  656. NORMAL-RAND                                                    [function-doc]
  657. Args: (n)\t<0>
  658. Returns a list of N standard normal random numbers. Vectorized.\b\ff<(CG)Times>
  659. \B\ff<(CG)Courier>\t<-1>---------------------------------------------------------------------------
  660. \ll<-2>>\t<0>\ll<-3>
  661. \b\ff<(CG)Times>
  662. The s\ll<1>ymbols \B\ff<(CG)Courier>norm\b\ff<(CG)Times>, \B\ff<(CG)Courier>norm-2\b\ff<(CG)Times> and \B\ff<(CG)Courier>normal\b\ff<(CG)Times> do not have function definitions and thus there is no help available for them. The term \Ivectorized\i in a function's documentation means the function can be applied to arguments that are lists or arrays; the result will be a list or array of the results of applying the function to each element of its arguments.\SP10\Sp A related term appearing in the documentation of some functions is \Ivector reducing\i. A function is vector reducing if it is applied recursively to its arguments until a single number results. The functions \B\ff<(CG)Courier>sum\b\ff<(CG)Times>, \B\ff<(CG)Courier>prod\b\ff<(CG)Times>, \B\ff<(CG)Courier>max\b\ff<(CG)Times> and \B\ff<(CG)Courier>min\b\ff<(CG)Times> are vector reducing.
  663. \piThe first time a help function is used will take some time - the help file is scanned and the positions of all entries in the file are recorded. Subsequent calls will be faster.
  664. Let me briefly explain the notation used in the information printed by \B\ff<(CG)Courier>help\b\ff<(CG)Times> to describe the arguments a function expects\SP11\Sp.  Most functions expect a fixed set of arguments, described in the help message by a line like\pn\ll<-2>
  665. \B\ff<(CG)Courier>Args: (x y z)\b\ff<(CG)Times>
  666. Some functions can tak\ll<1>e one or more optional arguments. The arguments for such a function might be listed as\ll<-2>
  667. \B\ff<(CG)Courier>Args: (x &optional y (z t))\b\ff<(CG)Times>
  668. This means t\ll<1>hat \B\ff<(CG)Courier>x\b\ff<(CG)Times> is required and \B\ff<(CG)Courier>y\b\ff<(CG)Times> and \B\ff<(CG)Courier>z\b\ff<(CG)Times> are optional.  If the function is named \B\ff<(CG)Courier>f\b\ff<(CG)Times>, it can be called as \B\ff<(CG)Courier>(f x-val)\b\ff<(CG)Times>, \B\ff<(CG)Courier>(f x-val y-val)\b\ff<(CG)Times> or \B\ff<(CG)Courier>(f x-val y-val z-val)\b\ff<(CG)Times>. The list \B\ff<(CG)Courier>(z t)\b\ff<(CG)Times> means that if \B\ff<(CG)Courier>z\b\ff<(CG)Times> is not supplied its default value is \B\ff<(CG)Courier>T\b\ff<(CG)Times>. No explicit default value is specified for \B\ff<(CG)Courier>y\b\ff<(CG)Times>; its default value is therefore \B\ff<(CG)Courier>NIL\b\ff<(CG)Times>. The arguments must be supplied in the order in which they are listed. Thus if you want to give the argument \B\ff<(CG)Courier>z\b\ff<(CG)Times> you must also give a value for \B\ff<(CG)Courier>y\b\ff<(CG)Times>.
  669. \piAnother form of optional argument is the \Ikeyword argument\i. Thehistogram function for example takes arguments\pn\ll<-3>
  670. \B\ff<(CG)Courier>Args: (data &key (title "Histogram"))\b\ff<(CG)Times>
  671. The \B\ff<(CG)Courier>data\b\ff<(CG)Times> argument is req\ll<0>uir\ll<1>ed, the \B\ff<(CG)Courier>title\b\ff<(CG)Times> argument is an optional keyword argument. The default title is \B\ff<(CG)Courier>"Histogram"\b\ff<(CG)Times>. If you want to create a histogram of the purchases data set used in Section 3.1 with title \B\ff<(CG)Courier>"Purchases"\b\ff<(CG)Times> use the expression\ll<-3>
  672. \B\ff<(CG)Courier>(histogram purchases :title "Purchases")\b\ff<(CG)Times>
  673. Thus to give a value for a keyword argument\ll<0> \ll<1>you give the keyword\SP12\Sp for the argument, a symbol consisting of a colon followed by the argument name, and then the value for the argument. If a function can take several keyword arguments then these may be specified in any order, following the required and optional arguments.
  674. \piFinally, some functions can take an arbitrary number of arguments. This is denoted by a line like\pn\ll<-3>
  675. Args: (x &rest args)
  676. The argum\ll<1>ent \B\ff<(CG)Courier>x\b\ff<(CG)Times> is required, and zero or more additional arguments can be supplied.
  677. \piIn addition to providing information about functions \B\ff<(CG)Courier>help\b\ff<(CG)Times> also gives information about data types and certain variables. For example,\pn
  678. \B\ff<(CG)Courier>> (help 'complex)
  679. COMPLEX\s\s \s\s\s\s\s\s\s[function-doc]
  680. Args: (realpart &optional (imagpart 0))
  681. Returns a complex number with the given real and imaginary parts.
  682. COMPLEX\s\s \s\s\s\s\s\s\s[type-doc]
  683. A complex number
  684. >\b\ff<(CG)Times>\ll<-3>
  685. \ll<-2>
  686. shows the function and type documentation for \B\ff<(CG)Courier>complex\b\ff<(CG)Times>, and
  687. \ll<-3>
  688. \B\ff<(CG)Courier>> (help\ll<0> \ll<1>'pi)
  689. PI\s\s [variable-doc]
  690. T\t<-1>he floating-point number that is approximately equal to the ratio of the\t<0>
  691. circumference of a circle to its diameter.
  692. >\b\ff<(CG)Times>\ll<-3>
  693. \ll<1>
  694. shows the variable documentation for \B\ff<(CG)Courier>pi\b\SP\ff<(CG)Times>13\Sp.
  695. \B5.2  Listing and Undefining Variables\b
  696. After you have been working for a while you may want to find out what variables you have defined (using \B\ff<(CG)Courier>def\b\ff<(CG)Times>). The function \B\ff<(CG)Courier>variables\b\ff<(CG)Times> will produce a listing:
  697. \ll<-3>
  698. \B\ff<(CG)Courier>> (varia\ll<0>b\ll<1>les)
  699. RURAL
  700. URBAN
  701. PRECIPITATION
  702. PURCHASES
  703. >\b\ff<(CG)Times>\ll<-4>
  704. \ll<-1>
  705. \pi\ll<1>If you are working on a 1Mb Macintosh you may occasionally want to free up some space by getting rid of some variables you no longer need. You can do this using the\B \ff<(CG)Courier>undef\b\ff<(CG)Times> function:\pn
  706. \ll<-3>
  707. \B\ff<(CG)Courier>> (\ll<0>unde\ll<1>f 'co)
  708. > (variables)
  709. RURAL
  710. URBAN
  711. PRECIPITATION
  712. PURCHASES
  713. >\b\ff<(CG)Times>\ll<-3>
  714. \ll<1>
  715. \B5.3  More on the XLISP-STAT Listener\b\ll<0>
  716. \ll<1>
  717. Because of the large number of parentheses involved, Lisp expressions can be hard to read and type correctly. To make it easier to type readable, correct expressions the listener window on the Macintosh has the following features: 
  718. \s\po
  719.  Typing a left parenthesis flashes the matching right parenthesis.\ll<-1>
  720. \ll<1>
  721.  You can move the cursor with the arrow keys, the mouse or the \Ibackspace\i key to any  \T\Tposition in the current input expression, not just within the last line.\ll<-1>
  722. \ll<1>
  723.  If the current expression is more than one line long, hitting the \Itab\i key in any line but the \T\Tfirst indents the line to its appropriate position according to (more or less) standard rules for \T\TLisp code indentation.\ll<-1>
  724. \ll<1>
  725.  If the insertion point is at the end of the current expression hitting the \Ienter\i key is \T\Tequivalent to hitting a \Ireturn\i. If the insertion point is not at the end of the expression, \T\Thitting \Ienter\i moves the insertion point to the end of the expression.\pn
  726. These four features should make typing expressions correctly much easier. In particular, in translating mathematical formulas to Lisp it sometimes seems that you have to do things backwards. Using these features you can build up your expression from the inside out\SP14\Sp.
  727. \piXLISP 2.0 provides a simple command history mechanism. The symbols \B\ff<(CG)Courier>-\b\ff<(CG)Times>, \B\ff<(CG)Courier>*\b\ff<(CG)Times>, \B\ff<(CG)Courier>**\b\ff<(CG)Times>, \B\ff<(CG)Courier>***\b\ff<(CG)Times>, \B\ff<(CG)Courier>+\b\ff<(CG)Times>, \B\ff<(CG)Courier>++\b\ff<(CG)Times>, and \B\ff<(CG)Courier>+++\b\ff<(CG)Times> are used for this purpose. The top level reader binds these symbols as follows:\pn\ll<-2>
  728. \ll<1>
  729. \s\s\s\s\s    \B\ff<(CG)Courier>-\b\ff<(CG)Times>\sthe current input expression
  730. \s\s\s\s\s    \B\ff<(CG)Courier>+\b\ff<(CG)Times>\sthe last expression read
  731. \s\s\s\s\s  \B\ff<(CG)Courier>++\s\b\ff<(CG)Times>the previous value of \B\ff<(CG)Courier>+\b\ff<(CG)Times>
  732. \s\s\s\s\s\B\ff<(CG)Courier>+++\t<2>\s\b\ff<(CG)Times>\t<0>the previous value of \B\ff<(CG)Courier>++\b\ff<(CG)Times>
  733. \s\s\s\s\s    \B\ff<(CG)Courier>*\t<-1>\s\b\ff<(CG)Times>\t<0>the result of the last evaluation
  734. \s\s\s\s\s  \B\ff<(CG)Courier>**\s\b\ff<(CG)Times>the previous value of \B\ff<(CG)Courier>*\b\ff<(CG)Times>
  735. \s\s\s\s\s\B\ff<(CG)Courier>***\s\b\ff<(CG)Times>the previous value of \B\ff<(CG)Courier>**\b\ff<(CG)Times>\ll<-2>
  736. \ll<1>
  737. The variables \B\ff<(CG)Courier>*\b\ff<(CG)Times>, \B\ff<(CG)Courier>**\b\ff<(CG)Times> and \B\ff<(CG)Courier>***\b\ff<(CG)Times> are probably most useful. For example, if you construct a plot but forget to assign the resulting plot object to a variable you can recover it using one of the history variables:\ll<-4>
  738. \ll<1>
  739. \B\ff<(CG)Courier>> (histogram (normal-rand 50))
  740. #<Object: 3701682, prototype = HISTOGRAM-PROTO>
  741. > (def w *)
  742. #<Object: 3701682, prototype = HISTOGRAM-PROTO>
  743. > \b\ff<(CG)Times>\ll<-4>
  744. \ll<1>
  745. The symbol \B\ff<(CG)Courier>W\b\ff<(CG)Times> now has the histogram object as its value and can be used to modify the plot, as described in Section 6.5 below.
  746. \piLike most interactive systems, XLISP needs a system for dynamically managing memory. The system used by XLISP is to grab memory out of a fixed bin until the bin is exhausted. At that point the system pauses to reclaim memory that is no longer being used. This process, called \Igarbage collection\i, will occasionally cause the system to freeze up for about a second. When the system garbage collects the Macintosh \pncursor changes to a trash bag.
  747. \piOccasionally a calculation will take too long, or it will appear to \pnhave gotten stuck in some kind of loop. If you want to interrupt the calculation \Ihold down\i the COMMAND key and the PERIOD. This should return you to the listener. You must continue to hold down the key until the calculation stops.
  748. \B5.4  Loading Files\b
  749. The data for the examples and exercises in this tutorial have been stored on files with names ending in \B\ff<(CG)Courier>.lsp\b\ff<(CG)Times>.  On the XLISP-STAT distribution disk they can be found in the folder \B\ff<(CG)Courier>Data\b\ff<(CG)Times>. Any variables you save (see the next subsection for details) will also be saved on files of this form. The data in these files can be read into XLISP-STAT with the \B\ff<(CG)Courier>load\b\ff<(CG)Times> function. To load a file named \B\ff<(CG)Courier>randu.lsp\b\ff<(CG)Times> type the expression
  750. \ll<-2>
  751. \B\ff<(CG)Courier>(load "randu.lsp")\b\ff<(CG)Times>
  752. \ll<1>
  753. or just
  754. \ll<-2>
  755. \B\ff<(CG)Courier>(load "randu")\b\ff<(CG)Times>
  756. \ll<1>
  757. If you give \B\ff<(CG)Courier>load\b\ff<(CG)Times> a name that does not end in\B \ff<(CG)Courier>.lsp\b\ff<(CG)Times> then load will add this suffix. Alternatively, you can use the \BLoad\b command in the \BFile\b menu. After loading a file using the \BFile\b menu \BLoad\b item the system does not print a prompt. Instead it prints a message indicating that the load is done:
  758. \ll<-2>
  759. \B\ff<(CG)Courier>> ; loading "temp.lsp"\ll<1>
  760. ; finished loading "temp.lsp"\b\ff<(CG)Times>\ll<-2>
  761. \ll<1>
  762. \B5.5  Saving Your Work\b
  763. If you want to record a session with XLISP-STAT you can do so using the \B\ff<(CG)Courier>dribble\b\ff<(CG)Times> function. The expression
  764. \ll<-2>
  765. \B\ff<(CG)Courier>(dribble "myfile")\b\ff<(CG)Times>
  766. \ll<1>
  767. starts a recording. All expressions typed by you and all results typed by XLISP-STAT will be entered into the file named \B\ff<(CG)Courier>myfile\b\ff<(CG)Times>. The expression
  768. \ll<-2>
  769. \B\ff<(CG)Courier>(dribble)\b\ff<(CG)Times>
  770. \ll<1>
  771. stops the recording. Note that \B\ff<(CG)Courier>(dribble "myfile")\b\ff<(CG)Times> starts a new file by the name \B\ff<(CG)Courier>myfile\b\ff<(CG)Times>. If you already have a file by that name its contents will be lost. Thus you can't use dribble to toggle on and off recording to a single file. You can also turn dribbling on and off using the \BDribble\b item on the \BCommand\b menu.
  772. \B\ff<(CG)Courier>\pidribble\b\ff<(CG)Times> only records text that is typed, not plots. However, you can use the standard Macintosh shortcut COMMAND-SHIFT-3 to save a MacPaint image of the current screen. You can also choose the \BCopy\b command from the \BEdit\b menu, or its command key shortcut COMMAND-C, while a plot window is the active window to save the contents of the plot window to the clip board. You can then open the scrap book from the apple menu and paste the plot into the scrap book.
  773. Variables you define in XLISP-STAT only exist for the duration of the current session. If you quit from XLISP-STAT, or the program crashes, your data will be lost. To preserve your data you can use the \B\ff<(CG)Courier>savevar\b\ff<(CG)Times> function. This function allows you to save one or more variables into a file. Again a new file is created and any existing file by the same name is destroyed. To save the variable \B\ff<(CG)Courier>precipitation\b\ff<(CG)Times> in a file called \B\ff<(CG)Courier>precipitation.lsp\b\ff<(CG)Times> type\pn
  774. \ll<-2>
  775. \B\ff<(CG)Courier>(savevar 'precipitation "precipitation")
  776. \b\ff<(CG)Times>\ll<1>Do not add the \B\ff<(CG)Courier>.lsp\b\ff<(CG)Times> suffix yourself; \B\ff<(CG)Courier>savevar\b\ff<(CG)Times> will supply it. To save the two variables \B\ff<(CG)Courier>precipitation\b\ff<(CG)Times> and \B\ff<(CG)Courier>purchases\b\ff<(CG)Times> in the file \B\ff<(CG)Courier>examples.lsp\b\ff<(CG)Times> type \SP15\Sp.
  777. \ll<-2>
  778. \B\ff<(CG)Courier>(savevar '(purchases precipitation) "examples")\b\ff<(CG)Times>\ll<1>
  779. The files \B\ff<(CG)Courier>precipitation.lsp\b\ff<(CG)Times> and \B\ff<(CG)Courier>examples.lsp\b\ff<(CG)Times> now contain a set of expression that, when read in with the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command, will recreate the variables \B\ff<(CG)Courier>precipitation\b\ff<(CG)Times> and \B\ff<(CG)Courier>purchases\b\ff<(CG)Times>. You can look at these files with an editor like MacWrite or the XLISP-STAT editor and you can prepare files with your own data by following these examples.
  780. \B5.6  The XLISP-STAT Editor\b
  781. The Macintosh version of XLISP-STAT includes a simple editor for preparing data files and function definitions. To edit an existing file select the \BOpen Edit\b item on the \BFile\b menu; to start a new file select \BNew Edit\b. Other commands on the \BFile\b menu can be used to save your file and to revert back to the saved version. The editor can only handle text files of less than 32K characters. As in the listener window, hitting the \Itab\i key in any line but the first of a multiline expression will indent the expression to a reasonable point. The editor also allows you to select a section of text representing one or more Lisp expressions and have these evaluated. To do this select the expressions you want to
  782. evaluate and then choose \BEval Selection\b from the \BEdit\b menu. The returned values are not available, so this is only useful for producing side effects, such as defining variables or functions.
  783. \B5.7  Reading Data  Files\b
  784. The data files we have used so far in this tutorial have been processed to contain XLISP-STAT expressions.  XLISP-STAT also provides two functions for reading raw data files. The simpler of the two is \B\ff<(CG)Courier>read-data-file\b\ff<(CG)Times>. The expression
  785. \B\ff<(CG)Courier>(read-data-file file)\b\ff<(CG)Times>
  786. where\B \ff<(CG)Courier>file\b\ff<(CG)Times> is a string representing the name of the data file, returns a list of all the items in the file. Items can be separated by any amount of white space, but not by commas or other punctuation marks.  Items can be any valid Lisp expressions. In particular they can be numbers, strings or symbols. The list can then be manipulated into the appropriate form within XLISP-STAT.
  787. \piThe function \B\ff<(CG)Courier>read-data-columns\b\ff<(CG)Times> is provided for reading data files in which each row represents a case and each column a variable. The expression\pn
  788. \B\ff<(CG)Courier>(read-data-columns file cols)\b\ff<(CG)Times>
  789. will return a list of \B\ff<(CG)Courier>cols\b\ff<(CG)Times> lists, each representing a column of the file. Note that this function determines the column structure from the value of \B\ff<(CG)Courier>cols\b\ff<(CG)Times>, not from the structure of the file. The entries of \B\ff<(CG)Courier>file\b\ff<(CG)Times> can be as for\B \ff<(CG)Courier>read-data-file\b\ff<(CG)Times>.
  790. \piThese two functions should be adequate for most purposes. If you have to read a file that does not fit into the form considered here you can use the raw file handling functions of XLISP.\pn
  791. \B5.8  User Initialization File\b
  792. After loading in all its program files and before giving you your first prompt XLISP-STAT looks to see if there is a file named \B\ff<(CG)Courier>statinit.lsp\b\ff<(CG)Times> in the startup folder. If there is one it will be loaded.  You can use this file to load any data sets you would like to have available or to define functions of your own.
  793. DPTXT
  794. L\n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp__________________________________________________\pi
  795. 9\Sp The on line help file may not be available on a single disk version that includes a system file. Alternatively, there may be a small help file available that does not contain documentation for all functions..\fs<12>
  796. e( PTXT
  797. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp24\.
  798. e:tPBOX
  799. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp__________________________________________\fs<12>
  800.  \SP\fs<10>\pi10\SpThis process of applying a function elementwise to its arguments is called \Imapping\i.\pn
  801. \SP\pi11\SpThe notation used corresponds to the specification of the argument lists in Lisp function definitions. See Section 8 for more information on defining functions.\fs<12>
  802. \SP\fs<10>12\Sp\pnNote that the keyword \B\ff<(CG)Courier>:title\b\ff<(CG)Times> has not been quoted.  \IKeyword symbols\i, symbols starting with a colon, are somewhat special.  When a keyword symbol is created its value is set to itself. Thus a keyword symbol effectively evaluates to itself and does not need to be quoted.\fs<12>\pi
  803. f@mPBOX
  804. fCCPBOX
  805. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp25\.
  806. fZsPTXT
  807. \n\SP\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________________________\pi
  808. 13\SpActually \B\ff<(CG)Courier>pi \b\ff<(CG)Times>represents a constant, produced with {defconst}. Its value can't be changed by simple assignment.\.
  809. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp26\.
  810. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_______________________________________
  811. \SP\pi14\SpTo support these features the listener checks the current expression each time you type a {return} to see if it has a complete expression. If so, the expression is passed to the reader and the evaluator. If not, you can continue typing. There are some heuristics involved here, and an expression with lots of quotes and comments may cause trouble, but it seems to work. Redefining the read table in major\fs<12> \fs<10>ways may not work as you think since some knowledge of standard Lisp syntax is built in to the listener.\fs<12>\pn
  812. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp27\.
  813. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp28\.
  814. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_______________________________________________
  815. \SP\pi15\SpI have used a quoted list \B\ff<(CG)Courier>'(purchases precipitation)\ff<(CG)Times> \bin this expression to pass the list of symbols to the save function. A longer alternative would be the expression \B\ff<(CG)Courier>(list 'purchases 'precipitation)\b\ff<(CG)Times>.\pn
  816. h^iPPAG
  817. 5\n\ff<(CG)Times>\fs<12>\ll<2>\ps<100>\t<0>\Fp29\.
  818. hxOPTXT
  819. j&\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp6   More Elaborate Plots\b\fs<12>
  820. The plots described so far were designed for exploring the distribution of a single variable and the relationship among two ariables. This section describes some plots and techniques that are useful for exploring the relationship among three or more variables. The techniques and plots described in the first four subsections are simple, requiring only simple commands to the listener and mouse actions. The fifth subsection introduces the concept of a \Iplot object\i and the idea of \Isending messages\i to an object from the listener window.  These ideas are used to add lines and curves to scatter plots, and the basic concepts of objects and messages will be used again in the next section on regression models. The final subsection shows how Lisp iteration can be used to construct a dynamic simulation--a plot movie.
  821. \B6.1  Spinning Plots\b
  822. If we are interested in exploring the relationship among three variables then it is natural to imagine constructing a three dimensional scatterplot of the data. Of course we can only see a two dimensional projection of the plot on a computer screen -- any depth that you might be able to perceive by looking at a wire model of the data is lost.  One approach to try to recover some of this depth perception is to rotate the points around some axis. The \B\ff<(CG)Courier>spin-plot\b\ff<(CG)Times> function allows you to construct a rotatable three dimensional plot.
  823. \piAs an example let's look a some data collected to examine the relationship between a phosphate absorption index and the amount of extractable iron and aluminum in a sediment (Devore and Peck [11, page 509, Example 6]). The data can be entered with the expressions \pn
  824.  \ll<-2>
  825. \B\ff<(CG)Courier>(\t<-1>def iron (list\t<0> 61 175 111 124 130\ll<1> 173 169 169 160 224 257 333 199))
  826. (def aluminum (list 13 21 24 23 64 38 33 61 39 71 112 88 54)) 
  827. (def absorption (list 4 18 14 18 26\ll<-2> 26 21 30 28 36 65 62 40))\b\ff<(CG)Times>
  828. The expression
  829. \B\ff<(CG)Courier>(spin-plot (list absorption iron aluminum))\b\ff<(CG)Times>
  830. \ll<1>
  831. produces the plot on the left in Figure 7.  The argument to \B\ff<(CG)Courier>spin-plot\b\ff<(CG)Times> is a list of three lists or vectors, representing the \Ix\i, \Iy\i and \Iz\i variables. The \B\Iz\b\i axis is initially pointing out of the screen. You can rotate the plot by pointing at one of the \B\ff<(CG)Courier>Pitch\b\ff<(CG)Times>,\B \ff<(CG)Courier>Roll\b\ff<(CG)Times> or \B\ff<(CG)Courier>Yaw\b\ff<(CG)Times> squares and pressing the mouse button. By rotating the plot you can see that the points seem to fall close to a plane. The plot on the right of Figure 7 shows the data viewed along the plane.  A linear model should describe this data quite well.
  832. \piAs a second example, with the data defined by \pn
  833. \ll<-2>
  834. \B\ff<(CG)Courier>(def strength (list 14.7 48.0 \ll<1>25.6 10.0 16.0 16.8 20.7 38.8
  835.                     \s\s\s\s16.9 27.0 16.0 24.9 7.3 12.8))
  836. \t<-1>(def depth (list 8.9 36.6 36.8 6.1 6.9 6.9\t<0> \t<-1>7.3 8.4 6.5 8.0 4.5 9.9 2.9 2.0))\t<0>
  837. (def water (list 31.5 27.0 25.9 39.1 39.2 38.3 33.9 33.8
  838.                  \s\s\s\s27.9 33.\ll<-2>1 26.3 37.8 34.6 36.4))\b\ff<(CG)Times>
  839. \ll<1>
  840. (Devore and Peck [11, Problem 12.18]) the expression
  841. \ll<-2>
  842. \B\ff<(CG)Courier>(spin-plot (list water depth strength)\ll<1>
  843.            \s\s\s:variable-labels (list "Water" "Depth" "Strength"))\b\ff<(CG)Times>\ll<-2>
  844.                                   \ll<1>
  845. produces a plot that can be rotated to produce the view in Figure 8. These data concern samples of thawed permafrost soil. \B\ff<(CG)Courier>strength\b\ff<(CG)Times> is the shear strength, and \B\ff<(CG)Courier>water\b\ff<(CG)Times> is the percentage water content. \B\ff<(CG)Courier>depth\b\ff<(CG)Times> is the depth at which the sample was taken. The plot shows that a linear model will not fit well. Devore and Peck [11] suggest fitting a model with quadratic terms to this data.
  846. \piThe function \B\ff<(CG)Courier>spin-plot\b\ff<(CG)Times> also accepts the additional keyword argument \B\ff<(CG)Courier>scale\b\ff<(CG)Times>. If \B\ff<(CG)Courier>scale\b\ff<(CG)Times> is \B\ff<(CG)Courier>T\b\ff<(CG)Times>, the default, then the data are centered at the midranges of the three variables, and all three variables are scaled to fit the plot. If scale is \B\ff<(CG)Courier>NIL\b\ff<(CG)Times> the data are assumed to be scaled between -1 and 1, and the plot is rotated about the origin. Thus if you want to center your plot at the means of the variables and scale all observations by the same amount you can use the expression\pn
  847. \ll<-4>
  848. \B\ff<(CG)Courier>(spin-plot (list (/ (- wa\ll<-2>ter (mean water)) 20\ll<1>)
  849.                  \s\s\s  (/ (- depth (mean depth)) 20)
  850.                  \s\s\s  (/ (- strength (mean strength)) 20))
  851.            \s\s:scale nil)\b\ff<(CG)Times>\ll<-4>
  852. \ll<1>
  853. Note that the \B\ff<(CG)Courier>scale\b\ff<(CG)Times> keyword argument is given using the corresponding keyword symbol, the symbol \B\ff<(CG)Courier>scale\b\ff<(CG)Times> preceded by a colon\pi.
  854. \T          \pnRotation speed can be changed using the plot menu or the keyboard equivalents COMMAND-F for Faster and COMMAND-S for Slower.\pi
  855. Depth cuing and showing of the axes are controlled by the items on the plot menu.
  856. If you click the mouse in one of the \B\ff<(CG)Courier>Pitch\b\ff<(CG)Times>, \B\ff<(CG)Courier>Roll\b\ff<(CG)Times> or \B\ff<(CG)Courier>Yaw\b\ff<(CG)Times> squares while holding down the \Ishift\i key the plot will start to rorate and continue to rotate after the mouse button has been released.\pn
  857. \BExercises\b\ll<-2>
  858. \ll<1>
  859. \po1. An Upstate New York business machine company used to include a random number generator called RANDU in its software library. This generator was supposed to produce numbers that behaved like \Ii. i. d.\i uniform random variables. The data set randu in the file\B \ff<(CG)Courier>randu.lsp\b\ff<(CG)Times> in the \BData\b folder consists of a list of three lists of numbers. These lists are consecutive triples of numbers produced by RANDU. Use \B\ff<(CG)Courier>spin-plot\b\ff<(CG)Times> to see if you can spot any unusual features in this sample.\pn
  860. \B6.2 \b \BScatterplot Matrices\b\ll<-2>
  861. \ll<1>
  862. Another approach to graphing a set of variables is to look at a matrix of all possible pairwise scatterplots of the variables. The\B \ff<(CG)Courier>scatterplot-matrix\b\ff<(CG)Times> function will produce such a plot. The data 
  863. \ll<-4>
  864. \B\ff<(CG)Courier>(def hard\ll<-2>ness (\ll<1>list 45 55 61 66 71 71 81 86 53 60 64 68 79 81 56
  865.                     \s\s\s\s68 75 83 88 59 71 80 82 89 51 59 65 74 81 86))
  866. (def tensile-strength (list 162 233 232 231 231 237 224 219 203 189 \s\s\s\s\s 210 210 196 180 200 173 188 161 119 161                             \s\s\s\s\s 151 165 151 128 161 146 148 144 134 127))
  867. (def abrasion-loss (list 372 206 175 154 136 112 55 45 221 166 164
  868.                          \s\s\s\s\s113  82  32 228 196 128 97 64 249 219 186
  869.                          \s\s\s\s\s155 114 341 340 284 267 215 148))\b\ff<(CG)Times>\ll<-4>
  870. \ll<1>
  871. were produced in a study of the abrasion loss in rubber tires and the expression
  872. \ll<-4>
  873. \B\ff<(CG)Courier>(scatter\ll<-1>plot-matrix (list har\ll<1>dness tensile-strength abrasion-loss)
  874.                     \s\s:variable-labels
  875.                     \s\s(list "Hardness" "Tensile Strength" "Abrasion Loss"))\b\ff<(CG)Times>\ll<-4>
  876. \ll<1>
  877. produces the scatterplot matrix in Figure 9. The plot of\B\ff<(CG)Courier> abrasion-loss\b\ff<(CG)Times> against t\B\ff<(CG)Courier>ensile-strength\ff<(CG)Times> \bgives you an idea of the joint variation in these two variables. But \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> varies from point to point as well. To get an understanding of the relationship among all three variables it would be nice to be able to fix \ff<(CG)Courier>hardness\ff<(CG)Times> at various levels and look at the way the plot of \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> against \B\ff<(CG)Courier>tensile-strength\b\ff<(CG)Times> changes as you change these levels.  You can do this kind of exploration in the scatterplot matrix by using the two highlighting techniques  \B\ff<(CG)Courier>selecting\b\ff<(CG)Times>  and \B\ff<(CG)Courier>brushing\b\ff<(CG)Times>.
  878. \jcFigure 9: Scatterplot matrix of abrasion loss data.\jf
  879. \s\I\poSelecting\i. Your plot is in the selecting mode when the cursor is an arrow. This is the default setting. In this mode select a point by clicking the mouse on top of it. To select a group of points drag a selection rectangle around the group. If the group does not fit in a rectangle you can build up your selection by holding down the \Ishift\i key as you click or drag. If you click without the \Ishift \ikey any existing selection will be unselected; when the \Ishift\i key is down selected points remain selected.\pn
  880. \s\I\poBrushing\i. You can enter the brushing mode by choosing \BMouse Mode...\b from the \BScatmat\b menu and selecting \BBrushing\b from the dialog box that is popped up. In this mode the cursor will look like a paint brush and a dashed rectangle, the \Ibrush\i, will be attached to your cursor. As you move the brush across the plot points in the brush will be highlighted. Points outside of the brush will not be highlighted unless they are marked as selected. To select points in the brushing mode (make their highlighting permanent) hold the mouse button down as you move the brush.
  881. \piIn the plot in Figure 10 the points within the middle of the \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> range have been highlighted using a long, thin brush (you can change the size of your brush using the \BResize Brush\b command on the \BScatmat\b menu). In the plot of\B \ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> against \B\ff<(CG)Courier>tensile-strength\b\ff<(CG)Times> you can see that the highlighted points seem to  follow a curve. If you want to fit a model to this data this suggests fitting a model that accounts for this  curvature.\pn
  882. \piA scatterplot matrix is also useful for examining the relationship between a quantitative variable and  several categorical variables. In the data\pn
  883. \B\ff<(CG)Courier>\t<-1>(def yield (list\t<0> \t<-1>7.9 9.2 10.5 11.2 12.8 13.3 12.1 12.6 14.0 9.1 10.8 12.5\t<0>
  884.                  \s8.1 8.6 10.1 11.5 12.7 13.7 13.7 14.4 15.5 11.3 12.5 14.5  \s15.3 16.1 17.5 16.6 18.5 19.2 18.0 20.8 21 17.2 18.4 18.9 )) 
  885. (def density (list 1 1 1 2 2 2 3 3 3 4 4 4 1 1 1 2 2 2 3 3 3 4 4 4 \b\ff<(CG)Times>
  886. \jcFigure 10: Scatterplot matrix with middle hardness values highlighted.
  887. \jf                   
  888. \s\s\B\ff<(CG)Courier>1 1 1 2 2 2 3 3 3 4 4 4))
  889. (def variety (list 1 1 1  1 1 1  1 1 1  1 1 1  2 2 2  2 2 2  2 2 2
  890.                    \s\s2 2 2  3 3 3  3 3 3  3 3 3  3 3 3))\b\ff<(CG)Times>
  891. (Devore and Peck [11, page 595, Example 14]) the yield of tomato plants is recorded for an experiment run at four different planting densities and using three different varieties. In the plot in Figure 11 a long, thin brush has been used to highlight the points in the third variety.  If there is no interaction between the varieties and the density then the shape of the highlighted points should move approximately in parallel as the brush is moved from one variety to another.
  892.  \piLike \B\ff<(CG)Courier>spin-plot\b\ff<(CG)Times>, the function \B\ff<(CG)Courier>scatterplot-matrix\b\ff<(CG)Times> also accepts the optional keyword argument \B\ff<(CG)Courier>scale\b\ff<(CG)Times>.\pn
  893. \BExercises\b
  894. \po1. Devore and Peck [11, Exercise 13.62] describe an experiment to determine the effect of oxygen concentration on fermentation end products. Four oxygen concentrations and two types of sugar were used. The data are\pn
  895. \s\B\ff<(CG)Courier>(def ethanol (list .59 .30 .25 .03 .44 .18 .13 .02 .22 .23 .07
  896.                    \s\s\s\s    .00 .12 .13 .00 .01))
  897. \s(def oxygen (list 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4))
  898. \s(def sugar (list 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 ))\b\ff<(CG)Times>
  899. and are on file \B\ff<(CG)Courier>oxygen.lsp\b\ff<(CG)Times>. Use a scatterplot matrix to examine these data.
  900. 2. Use scatterplot matrices to examine the data in the examples and exercises of Section 6.1 above.
  901. \jcFigure 11: Scatterplot matrix for tomato yield data with points from
  902. the third variety highlighted.\jf
  903. \B6.3  Interacting with Individual Plots\b
  904. Rotating plots and scatterplot matrices are interactive plots. Simple scatter plots also allow some interaction: If  you select the \BShow Labels\b option in the plot menu a label will appear next to a highlighted point. You can  use either the selecting or the brushing mode to highlight points. The default labels are of the form "0",  "1", ... . (In Lisp it is conventional to start numbering indices with 0, rather than 1.)  Most plotting\t<-1>  \t<0>unctions allow you to supply a list of case labels using the :\B\ff<(CG)Courier>point-labels\b\ff<(CG)Times> keyword.
  905. \piAnother option, useful in viewing large data sets, is to remove a subset of the points from your plot.  This can be done by selecting the points you want to remove and then choosing \BRemove Selection\b from  the plot menu. The plot can then be rescaled using the \BRescale Plot\b option. Alternatively, the \BFocus on Selection\b menu item removes all unselected points from the plot.
  906. When a set of points is selected in a plot you can change the symbol used to display the points using the \BSelection Symbol\b item. On systems with color monitors you can set the color of selected points with the \BSelection Color\b item.
  907. You can save the indices of the selected points in a variable by selecting the \BSelection...\b item in the plot menu. A dialog will ask you for a name for the selection. When no points are selected you can use the \BSelection...\b menu item to specify the indices of the points to select. A dialog will ask you for an expression for determining the selection to use. The expression can be any Lisp expression that evaluates to a list of indices\pn.
  908. \B6.4  Linked Plots\b
  909. When you brush or select in a scatterplot matrix you are looking at the interaction of a set of separate scatterplots\SP16\Sp.  You can construct your own set of interacting plots by choosing the \BLink View\b option \jcFigure 12: Scatterplot and histogram with points from one sugar group highlighted.\jf
  910. from the menus of the plots you want to link. For example, using the data from Exercise 1 in Section  6.2 we can put \B\ff<(CG)Courier>ethanol\b\ff<(CG)Times> and \B\ff<(CG)Courier>oxygen\b\ff<(CG)Times> in a scatterplot and \B\ff<(CG)Courier>sugar\b\ff<(CG)Times> in a histogram.  If we link these two plots then selecting one of the two sugar groups in the histogram highlights the corresponding points in the scatterplot, as shown in Figure 12. 
  911. If you want to be able to select the points with particular labels you can use the \B\ff<(CG)Courier>name-list\b\ff<(CG)Times> function to generate a window with a list of names in it. This window can be linked with any plot, and selecting a name in a name list will then highlight the corresponding points in the linked plots. You can use the \B\ff<(CG)Courier>name-list\b\ff<(CG)Times> function with a numerical argument; e. g.
  912. \B\ff<(CG)Courier>(name-list 10)\b\ff<(CG)Times>
  913. will generate a list with the names "0" , ..., "9", or you can give it a list of case labels of your own.
  914. \BExercise\b
  915. Try to use linked scatter plots and histograms on the data in the examples and exercises of Sections 6.1 and 6.2.
  916. \B6.5  Modifying a Scatter Plot\b
  917. After producing a scatterplot of a data set we might like to add a line, a regression line for example, to the plot. As an example, Devore and Peck [11, page 105, Example 2] describe a data set collected to examine the effect of bicycle lanes on drivers and bicyclists. The variables given by
  918. \B\ff<(CG)Courier>\t<-1>(def travel-space (list 12.8 12.9 12.9 13.6 14.5 14.6 15.1 17.5 19.5 20.8))\t<0>
  919. (def separation (list 5.5 6.2 6.3 7.0 7.8 8.3 7.1 10.0 10.8 11.0))\b\ff<(CG)Times>
  920. represent the distance between the cyclist and the roadway center line and the distance between the cyclist and a passing car, respectively, recorded in ten cases. A regression line fit to these data, with \B\ff<(CG)Courier>separation\b\ff<(CG)Times> as the dependent variable, has a slope of 0.66 and an intercept of -2.18. Let's see how to add this line to a scatterplot of the data.
  921. \piWe can use the expression \pn
  922. \B\ff<(CG)Courier>(plot-points travel-space separation)\b\ff<(CG)Times>
  923. to produce a scatterplot of these points. To be able to add a line to the plot, however, we must be able to refer to it within XLISP-STAT. To accomplish this let's assign the result returned by the p\B\ff<(CG)Courier>lot-points\b\ff<(CG)Times> function to a symbol\SP17\Sp:
  924. \B\ff<(CG)Courier>(def myplot (plot-points travel-space separation))\b\ff<(CG)Times>
  925. The result returned by plot-points is an xlisp \Iobject\i. To use an object you have to send it \Imessages\i. This is done using the \B\ff<(CG)Courier>send\b\ff<(CG)Times> function, as in the expression
  926. \ll<-1>
  927. \B\ff<(CG)Courier>(send object message argument1 ... )\b\ff<(CG)Times>
  928. I will use the expression
  929. \B\ff<(CG)Courier>(send myplot :abline\ll<1> -2.18 0.66)\b\ff<(CG)Times>
  930. to tell \B\ff<(CG)Courier>myplot\b\ff<(CG)Times> to add the graph of a line\I a\i + \Ib x\i, with \Ia\i = -2.18 and \Ib\i = 0.66, to itself. The \Imessage selector\i is \B\ff<(CG)Courier>:abline\b\ff<(CG)Times>, the numbers -2.18 and 0.66 are the arguments. The message consists of the selector and the arguments. Message selectors are always Lisp keywords; that is, they are symbols that start with a colon. Before typing in this expression you might want to resize and rearrange the listener window  so you can see the plot and type commands at the same time. Once you have resized the listener window you can easily switch between the small window and a full size window by clicking in the zoom box at the right corner of the window title bar. The resulting plot is shown in Figure 13.
  931. \piScatter plot objects  understand a number of other messages. One other message is the \B\ff<(CG)Courier>:help\b\ff<(CG)Times> message\SP18\Sp:\pn
  932. \ll<-2>
  933. \B\ff<(CG)Courier>> (send myplot :help)\ll<1>
  934. > (send scatterplot-proto :help)
  935. SCATTERPLOT-PROTO
  936. Scatterplot.
  937. Help is available on the following:\ll<-2>
  938. \ll<1>
  939. \t<-1>:ABLINE :ACTIVATE :ADD-FUNCTION :ADD-LINES :ADD-METHOD :ADD-MOUSE-MODE 
  940. :ADD-POINTS :ADD-SLOT :ADD-STRINGS :ADJUST-HILITE-STATE
  941. :ADJUST-POINT-SCREEN-STATES :ADJUST-POINTS-IN-RECT :ADJUST-TO-DATA
  942. :ALL-POINTS-SHOWING-P :ALL-POINTS-UNMASKED-P :ALLOCATE
  943. :ANY-POINTS-SELECTED-P :APPLY-TRANSFORMATION :BACK-COLOR :BRUSH\b\ff<(CG)Times>\t<0>
  944. \B\ff<(CG)Courier>\t<-1>:BUFFER-TO-SCREEN :CANVAS-HEIGHT :CANVAS-WIDTH :CLEAR :CLEAR-LINES\b\ff<(CG)Times>\t<0>
  945. \B\ff<(CG)Courier>\t<-1>:CLEAR-MASKS :CLEAR-POINTS :CLEAR-STRINGS ....\b\ff<(CG)Times>\t<0>
  946. \jcFigure 13: Scatterplot of bicycle data with fitted line.\jf
  947. \piThe list of topics will be the same for all scatter plots but will be somewhat different for rotating plots, scatterplot matrices or histograms.
  948. The \B\ff<(CG)Courier>:clear\b\ff<(CG)Times> message,  as its name suggests, clears the plot and allows you to build up a new plot from scratch. Two other useful messages are \B\ff<(CG)Courier>:add-points\b\ff<(CG)Times> and \B\ff<(CG)Courier>:add-lines\b\ff<(CG)Times>. To find out how to use them we can use the \B\ff<(CG)Courier>:help\b\ff<(CG)Times> message with \B\ff<(CG)Courier>:add-points\b\ff<(CG)Times> or \B\ff<(CG)Courier>:add-lines\b\ff<(CG)Times> as arguments: \pn
  949. \ll<-2>
  950. \B\ff<(CG)Courier>> (send myplo\ll<1>t :help :add-points)
  951. :ADD-POINTS
  952. Method args: (points &key point-labels (draw t))
  953. \t<-1>Adds points to plot. POINTS is a list of sequences, POINT-LABELS a list of
  954. strings. If DRAW is true the new points are added to the screen.\t<0>
  955. > (send myplot :help :add-lines)
  956. :ADD-LINES
  957. Method args: (lines &key type (draw t))
  958. \t<-1>Adds lines to plot. LINES is a list of sequences, the coordinates of the line 
  959. starts. TYPE is normal or dashed. If DRAW is true the new lines are added to the screen.\t<0>
  960. > \b\ff<(CG)Times>\ll<-2>
  961. \ll<1>
  962. The plot produced above shows some curvature in the data.  A regression of \B\ff<(CG)Courier>separation\b\ff<(CG)Times> on a linear and a quadratic term in \B\ff<(CG)Courier>travel-space\b\ff<(CG)Times> produces estimates of -16.41924 for the constant, 2.432667 as the coefficient of the linear term and -0.05339121 as the coefficient of the quadratic term. Let's use the \B\ff<(CG)Courier>:clear\b\ff<(CG)Times>, \B\ff<(CG)Courier>:add-points\b\ff<(CG)Times> and\B \ff<(CG)Courier>:add-lines\b\ff<(CG)Times> messages to change \B\ff<(CG)Courier>myplot\b\ff<(CG)Times> to show the data along with the fitted quadratic model. First we use the expressions
  963. \B\ff<(CG)Courier>(def x (rseq 12 22 50))\b\ff<(CG)Times>
  964. \jcFigure 14: Scatterplot of bicycle data with fitted curve.\jf
  965. \B\ff<(CG)Courier>(def y (+ -16.41924 (* 2.432667 x) (* -0.05339121 (* x x))))\b\ff<(CG)Times>
  966. to define \B\ff<(CG)Courier>x\b\ff<(CG)Times> as a grid of 50 equally spaced points between 12 and 22 and \B\ff<(CG)Courier>y\b\ff<(CG)Times> as the fitted response at these \B\ff<(CG)Courier>x\b\ff<(CG)Times> values. Then the expressions
  967. \ll<-2>
  968. \B\ff<(CG)Courier>(send myplot :clear)\ll<1>
  969. (send myplot :add-points travel-space separation)
  970. (send myplot :add-lines x y)\b\ff<(CG)Times>\ll<-2>
  971. \ll<1>
  972. change myplot to look like Figure 14. Of course we could have used\B \ff<(CG)Courier>plot-points\b\ff<(CG)Times> to get a new plot and just modified that plot with \B\ff<(CG)Courier>:add-lines\b\ff<(CG)Times>, but the approach used here allowed us to try out all three messages.
  973. \B6.6  Dynamic Simulations\b
  974. As another illustration of what you can do by modifying existing plots let's construct a dynamic simulation  - a movie - to examine the variation in the shape of histograms of samples from a standard normal  distribution. To start off, use the expression 
  975. \ll<-2>
  976. \B\ff<(CG)Courier>(def h (histogram (normal-rand 20)))\b\ff<(CG)Times>
  977. \ll<1>
  978. to construct a single histogram and save its plot object as \B\ff<(CG)Courier>h\b\ff<(CG)Times>. The \B\ff<(CG)Courier>:clear\b\ff<(CG)Times> message is available for histograms  as well. As you can see from its help message
  979. \ll<-2>
  980. \B\ff<(CG)Courier>> (send h :help :clear)\ll<1>
  981. :CLEAR
  982. Message args: (&optional (draw t))
  983. C\t<-1>lears the plot data. If DRAW is nil the plot is redrawn; otherwise\t<0> its\b\ff<(CG)Times>
  984. \B\ff<(CG)Courier>current screen image remains unchanged.
  985. >\b\ff<(CG)Times>\ll<-2>
  986. \ll<1>
  987. it takes an optional argument. If this argument is \B\ff<(CG)Courier>NIL\b\ff<(CG)Times> then the plot will not actually be redrawn until some other  event causes it to be redrawn. This is useful for dynamic simulations. Rearrange and resize your windows  until you can see the histogram window even when the listener window is the active window. Then type the expression\SP19\Sp 
  988. \ll<-2>
  989. \B\ff<(CG)Courier>(dotimes \s(i 50)\ll<1>
  990.          \s\s(send h :clear nil)
  991.          \s\s(send h :add-points (normal-rand 20)))\b\ff<(CG)Times>\ll<-3>
  992. \ll<1>
  993. This should produce a sequence of 50 histograms, each  based on a sample of size 20. By giving the keyword argument \B\ff<(CG)Courier>draw\b\ff<(CG)Times> with value \B\ff<(CG)Courier>NIL\b\ff<(CG)Times> to the \B\ff<(CG)Courier>:clear\b\ff<(CG)Times> message you have insured that each histogram stays on the screen until the next  one is ready to be drawn. Try the example again without this argument and see what difference it makes. 
  994. \piProgrammed dynamic simulations may provide another approach to viewing the relation among several variables. As a simple example, suppose we want to examine the relation between the variables\B \ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> and \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> introduced in Section 6.2 above. Let's start with a histogram of \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> produced by the expression\pn
  995. \ll<-2>
  996. \B\ff<(CG)Courier>(def h (histogram abrasion-loss))\b\ff<(CG)Times>
  997. \ll<1>
  998. The messages \B\ff<(CG)Courier>:point-selected\b\ff<(CG)Times>, \B\ff<(CG)Courier>:point-hilited\b\ff<(CG)Times> and \B\ff<(CG)Courier>:point-showing\b\ff<(CG)Times> are particularly useful for dynamic simulations. Here is the help information for \B\ff<(CG)Courier>:point-selected\b\ff<(CG)Times> in a histogram:
  999. \ll<-1>
  1000. \B\ff<(CG)Courier>> (send h :help :point-selected)\ll<1>
  1001. :POINT-SELECTED
  1002. Method args: (point &optional selected)
  1003. Sets or returns selection status (true or NIL) of POINT. Sends 
  1004. :ADJUST-POINT-SCREEN-STATES message if states are set. Vectorized.
  1005. > \b\ff<(CG)Times>\ll<-2>
  1006. \ll<1>
  1007. Thus you can use this message to determine whether a point is currently selected and also to select or unselect it. Again rearrange the windows so you can see the histogram while typing in the listener window and type the expression
  1008. \ll<-2>
  1009. \B\ff<(CG)Courier>(dolist \s(i (order hardness))\ll<1>
  1010.         \s\s(send h :point-selected i t)
  1011.         \s\s(send h :point-selected i nil))\b\ff<(CG)Times>\ll<-2>
  1012. \ll<1>
  1013. The expression \B\ff<(CG)Courier>(order hardness)\b\ff<(CG)Times> produces the list of indices of the ordered values of hardness.  Thus the first element of the result is the index of the smallest element of hardness, the second element is the index of the second smallest element of hardness, etc.. The loop moves through each of these indices and selects and unselects the corresponding point.
  1014.  \piThe result on the screen is very similar to the result of brushing a \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> histogram linked to an \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> histogram from left to right. The drawback of this approach is that it is harder to write an  expression than to use a mouse. On the other hand, when brushing with a mouse you tend to focus your  attention on the plot you are brushin\png, rather than on the other linked plots. When you run a dynamic  simulation you do not have to do anything while the simulation is running and can therefore concentrate fully  on the results.
  1015. An intermediate solution is possible: You can set up a dialog with a scroll bar that will run through the indices in the list \B\ff<(CG)Courier>(order hardness)\b\ff<(CG)Times>, selecting the corresponding point as it is scrolled. An example in Section 8 will show you how to do this.
  1016. Like most Lisp systems XLISP-STAT is not ideally suited to real time simulations because of the need for garbage collection, to reclaim dynamically allocated storage. This is the reason that the simulations in this section will occasionally pause for a second or two. Nevertheless, in a simple simulation like the last one each iteration may still be too fast for you to be able to pick up any pattern. To slow things down you can add some extra busy work to each iteration. For example, you could use
  1017. \B\ff<(CG)Courier>(dolist \s(i (order hardness))
  1018.         \s\s(send h :point-selected i t)
  1019.         \s\s(dotimes (i 100))
  1020.         \s\s(send h :point-selected i nil))\b\ff<(CG)Times>
  1021. in place of the previous expression.
  1022. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp30\.
  1023. \n\ff<(CG)Times>\fs<12>\jc\ll<1>\ps<100>\t<0>\FpFigure 7: Two views of a rotatable plot of data on iron content, aluminum content and phosphate absorption in sediment samples.\jf
  1024. \jcFigure 8: Rotatable plot of measurements on permafrost samples.\jf
  1025. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp31\.
  1026. =PBOX
  1027. ZPBOX
  1028. +PBOX
  1029. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp32\.
  1030. 2PBOX
  1031. PPBOX
  1032. (PBOX
  1033. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp33\.
  1034. PPPAG
  1035. :PBOX
  1036. dPBOX
  1037. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp34\.
  1038. OPPAG
  1039. &PBOX
  1040. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_____________________________________________
  1041. \SP16\SpAccording to Stuetzle [16] the idea to link several plots was first suggested by McDonald [12].
  1042. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp35\.
  1043. V^PBOX
  1044. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp36\.
  1045. R\n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp____________________________________________
  1046. \SP\pi17\SpThe result returned by \B\ff<(CG)Courier>plot-points\b\ff<(CG)Times> is printed something  like \B\ff<(CG)Courier>#<Object: 2010278, prototype = SCATTERPLOT-PROTO>\b\ff<(CG)Times>. This is not the value returned by the function, just its printed representation . There are several other data types that are printed this way; \Ifile streams\i, as returned by the \B\ff<(CG)Courier>open\b\ff<(CG)Times> function, are one example. For the most part you can ignore these printed results.  There is one unfortunate feature, however: the form \B\ff<(CG)Courier>#<...>\b\ff<(CG)Times> means that there is no printed form of this data type that the Lisp reader can understand. As a result, if you forget to give your plot a name you can't cut and paste the result into a \B\ff<(CG)Courier>def\b\ff<(CG)Times> expression -- you have to  redo the plot or use the history mechanism.
  1047. \SP18\Sp\pnTo keep things simple I will use the term \Imessage \ito refer to a message corresponding to a message selector.
  1048. 1PBOX
  1049. |PTXT
  1050. 9\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<-1>\Fp37\.
  1051. ]PPAG
  1052. %PBOX
  1053. 8PBOX
  1054.     ^PTXT
  1055. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp38\.
  1056.  aPBOX
  1057. ">PTXT
  1058. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp39\.
  1059. 5'PBOX
  1060. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp40\.
  1061. \n\B\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp____________________________________\ff<(CG)Courier>
  1062. \SP\ff<(CG)Times>\pi19\Sp\ff<(CG)Courier>dotimes\b\ff<(CG)Times> is one of several Lisp looping constructs. It isa special form with the syntax \B\ff<(CG)Courier>(dotimes (var count) expr  ....)\b\ff<(CG)Times>. The loop is repeate\pnd \B\ff<(CG)Courier>count\b\ff<(CG)Times> times, with \B\ff<(CG)Courier>var\b\ff<(CG)Times> bound to 0, 1, ..., \B\ff<(CG)Courier>count\b\ff<(CG)Times> - 1. Other looping constructs are \B\ff<(CG)Courier>dolist\b\ff<(CG)Times>, \B\ff<(CG)Courier>do\b\ff<(CG)Times>  and \B\ff<(CG)Courier>do*\b\ff<(CG)Times>.
  1063. +yPBOX
  1064. .mPTXT
  1065. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp41\.
  1066. @KPPAG
  1067. CNPBOX
  1068. DAPTXT
  1069. 6\n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________
  1070. \SP\pi20\SpRecall from Section 6.5 that \B\ff<(CG)Courier>#<Object: 1966006, prototype = REGRESSION-MODEL-PROTO>\b\ff<(CG)Times> is the printed representation of the model object returned by \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times>.  Unfortunately you can't cut and paste it\pn into the \B\ff<(CG)Courier>def\b\ff<(CG)Times>, but of course you can cut and paste the \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> expression or use the history mechanism.
  1071. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp42\.
  1072. QPBOX
  1073. #%\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp7   Regression\b\fs<12>
  1074. Regression models have been implemented using XLISP-STAT's object and message sending facilities. These were introduced above in Section 6.5. You might want to review that section briefly before reading on.
  1075. \piLet's fit a simple regression model to the bicycle data of Section 6.5. The dependent variable is \B\ff<(CG)Courier>separation\b\ff<(CG)Times> and the independent variable is \B\ff<(CG)Courier>travel-space\b\ff<(CG)Times>. To form a regression model use the \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> function:\pn
  1076. \B\ff<(CG)Courier>> (regression-model travel-space separation)
  1077. Least Squares Estimates:
  1078. Constant               -2.182472   (1.056688)
  1079. Variable  0:           0.6603419   (0.06747931)
  1080. R Squared:              0.922901
  1081. Sigma hat:             0.5821083
  1082. Number of cases:              10
  1083. Degrees of freedom:            8
  1084. #<Object: 1966006, prototype = REGRESSION-MODEL-PROTO>
  1085. >\b\ff<(CG)Times>
  1086. The basic syntax for the \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> function is
  1087. \B\ff<(CG)Courier>(regression-model x y)\b\ff<(CG)Times>
  1088. For a simple regression \B\ff<(CG)Courier>x\b\ff<(CG)Times> can be a single list or vector. For a multiple regression \B\ff<(CG)Courier>x\b\ff<(CG)Times> can be a list of lists or vectors or a matrix. The \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> function also takes several optional keyword arguments. The most important ones are \B\ff<(CG)Courier>:intercept\b\ff<(CG)Times>, \B\ff<(CG)Courier>:print\b\ff<(CG)Times>, and \B\ff<(CG)Courier>:weights\b\ff<(CG)Times>. Both \B\ff<(CG)Courier>:intercept\b\ff<(CG)Times> and \B\ff<(CG)Courier>:print\b\ff<(CG)Times> are \B\ff<(CG)Courier>T\b\ff<(CG)Times> by default. To get a model without an intercept use the expression
  1089. \ll<-2>
  1090. \B\ff<(CG)Courier>(regression-model x y :intercept nil)\b\ff<(CG)Times>
  1091. \ll<1>
  1092. To form a weighted regression model use the expression
  1093. \ll<-2>
  1094. \B\ff<(CG)Courier>(regression-model x y :weights w)\b\ff<(CG)Times>
  1095. \ll<1>
  1096. where \B\ff<(CG)Courier>w\b\ff<(CG)Times> is a list or vector of weights the same length as \B\ff<(CG)Courier>y\b\ff<(CG)Times>.  The variances of the errors are assumed to be inversely proportional to the weights \B\ff<(CG)Courier>w\b\ff<(CG)Times>.
  1097. \piThe \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> function prints a very simple summary of the fit model and returns a model object as its result. To be able to examine the model further assign the returned model object to a variable using an expression like\SP20\Sp\pn
  1098. \ll<-2>
  1099. \B\ff<(CG)Courier>(def bikes (regression-model travel-space separation :print nil))\b\ff<(CG)Times>
  1100. \ll<1>
  1101. I have given the keyword argument \B\ff<(CG)Courier>:print nil\b\ff<(CG)Times> to suppress the printing of the summary, since we have already seen it. To find out what messages are available use the \B\ff<(CG)Courier>:help\b\ff<(CG)Times> message:
  1102. \B\ff<(CG)Courier>> (send bikes :help)
  1103. REGRESSION-MODEL-PROTO
  1104. Normal Linear Regression Model
  1105. Help is available on the following:
  1106. \t<-1>:ADD-METHOD\t<-2> \t<-1>:ADD-SLOT\t<-2> \t<-1>:BASIS\t<-2> \t<-1>:CASE-LABELS\t<-2> :\t<-1>COEF-ESTIMATES\t<-2> :\t<-1>COEF-STANDARD-ERRORS
  1107. :COMPUTE :COOKS-DISTANCES :DELTE-METHOD :DELETE-SLOT :DF :DISPLAY :DOC-TOPICS
  1108. :DOCUMENTATION :EXTERNALLY-STUDENTIZED-RESIDUALS :FIT-VALUES :GET-METHOD
  1109. :HAS-METHOD :HAS-SLOT :HELP :INCLUDED :INTERCEPT :INTERNAL-DOC :ISNEW
  1110. :LEVERAGES :METHOD-SELECTORS :NEW :NUM-CASES :NUM-COEFS :NUM-INCLUDED
  1111. :OWN-METHODS :OWN-SLOTS :PARENTS :PLOT-BAYES-RESIDUALS :PLOT-RESIDUALS
  1112. :PRECEDENCE-LIST :PREDICTOR-NAMES :PRINT :R-SQUARED :RAW-RESIDUALS
  1113. :RESIDUAL-SUM-OF-SQUARES :RESIDUALS :RESPONSE-NAME :RETYPE :SAVE :SHOW 
  1114. :SIGMA-HAT :SLOT-NAMES :SLOT-VALUE :STUDENIIZED-RESIDUALS :SUM-OF-SQUARES 
  1115. :SWEEP-MATRIX :TOTAL-SUM-OF-SQUARES :WEIGHTS :X :X-MATRIX :XTXINV :Y PROTO\t<0>
  1116. > \b\ff<(CG)Times>\ll<-2>
  1117. \ll<1>
  1118. Many of these messages are self explanatory, and many have already been used by the \B\ff<(CG)Courier>:display\b\ff<(CG)Times> message, which \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> sends to the new model to print the summary. As examples let's try the \B\ff<(CG)Courier>:coef-estimates\b\ff<(CG)Times> and \B\ff<(CG)Courier>:coef-standard-errors\b\ff<(CG)Times> messages\SP2\Sp: 
  1119. \ll<-2>
  1120. \B\ff<(CG)Courier>> (send bikes :coef-estimates)\ll<1>
  1121. (-2.182472 0.6603419)
  1122. > (send bikes :coef-standard-errors)
  1123. (1.056688 0.06747931)
  1124. >\b\ff<(CG)Times>\ll<-2>
  1125. \ll<1>
  1126. The \B\ff<(CG)Courier>:plot-residuals\b\ff<(CG)Times> message will produce a residual plot. To find  out what residuals are plotted against let's look at the help information: 
  1127. \ll<-2>
  1128. \B\ff<(CG)Courier>> (send bikes :help :plot-residuals)\ll<1>
  1129. :PLOT-RESIDUALS\b\ll<-2>
  1130. \BMessage args: (&optional x-values)\ll<1>
  1131. \t<-1>Opens a window with a plot of the residuals. If X-VALUES are not supplied 
  1132. the fitted values are used. The plot can be linked to other plots with the\t<0> 
  1133. \t<-1>link-views function. Returns a plot object.\t<0>
  1134. >\b\ff<(CG)Times>\ll<-3>
  1135. \ll<1>
  1136. Using the expressions
  1137. \ll<-3>
  1138. \B\ff<(CG)Courier>(plot-points travel-space separation)\ll<1>
  1139. (send bikes :plot-residuals travel-space)\b\ff<(CG)Times>\ll<-2>
  1140. \ll<1>
  1141. we can construct two plots of the data as shown in Figure 15. By linking the plots we can use the mouse to identify points in both plots simultaneously. A point that stands out is observation 6 (starting the count at 0, as usual).
  1142.                                \jcFigure 15: Linked raw data and residual plots for the bicycles example.\jf
  1143. The plots both suggest that there is some curvature in the data; this curvature is particularly pronounced in the residual plot if you ignore observation 6 for the moment. To allow for this curvature we might try to fit a model with a quadratic term in \B\ff<(CG)Courier>travel-space\b\ff<(CG)Times>:
  1144. \B\ff<(CG)Courier>>\t<-2> \t<0>(def\t<-3> \t<0>bikes2(regression-model\t<-2> \t<0>(list\t<-1> \t<0>travel-space\t<-1> \t<0>(^\t<-1> \t<0>travel-space 2))
  1145.                                  \s\s\s\s\s\sseparation))
  1146. Least Squares Estimates:
  1147. Constant               -16.41924   (7.848271)
  1148. Variable  0:            2.432667   (0.9719628)
  1149. Variable  1:          -0.05339121   (0.02922567)
  1150. R Squared:             0.9477923
  1151. Sigma hat:             0.5120859
  1152. Number of cases:              10
  1153. Degrees of freedom:            7
  1154. \ll<-2>
  1155. BIKES2\ll<1>
  1156. \ll<-2>>\b\ff<(CG)Times>
  1157. \ll<1>
  1158. I have used the exponentiation function "^" to compute the square of \B\ff<(CG)Courier>travel-space\b\ff<(CG)Times>. Since I am now forming a multiple regression model the first argument to \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times> is a list of the \B\ff<(CG)Courier>x\b\ff<(CG)Times> variables.
  1159. \piYou can proceed in many directions from this point. If you want to calculate Cook's distances for the observations you can first compute internally studentized residuals as\pn
  1160. \B\ff<(CG)Courier>(def studres (/ (send bikes2 :residuals)
  1161.                 \s\s\s (*  (send bikes2 :sigma-hat) 
  1162.                    \s\s\s\s(sqrt (- 1 (send bikes2 :leverages)))))) \b\ff<(CG)Times>
  1163. \jcFigure 16: Bayes residual plot for bicycle data.\jf
  1164. Then Cooks distances are obtained as\SP22\Sp
  1165. \B\ff<(CG)Courier>> (* (^ studres 2) 
  1166.      \s(/ (send bikes2 :leverages) (- 1 (send bikes2 :leverages)) 3))
  1167. \t<-1>(0.166673 0.00918596 0.03026801 0.01109897 0.009584418 0.1206654 0.581929 
  1168. 0.0460179 0.006404474 0.09400811)\b\ff<(CG)Times>\t<0>
  1169. The seventh entry - observation 6, counting from zero - clearly stands out.
  1170. \piAnother approach to examining residuals for possible outliers is to use the Bayesian residual plot proposed by Chaloner and Brant [7], which can be obtained using the message :\B\ff<(CG)Courier>plot-bayes-residuals\b\ff<(CG)Times>. The expression  \B\ff<(CG)Courier>(send bikes2 :plot-bayes-residuals)\b\ff<(CG)Times>  produces the plot in Figure 16.\pn The bars represent mean 
  1171. \ff<(CG)Symbol>
  1172. \ff<(CG)Times>2SD of the posterior distribution of the actual realized errors, based on an improper  uniform prior distribution on the regression coefficients. The \Iy\i axis is in units of \ff<(CG)Symbol>s\ff<(CG)Times>. Thus this plot suggests the probability that point 6 is three or more standard deviations from the mean is about 3%; the  probability that it is at least two standard deviations from the mean is around 50%. 
  1173. \BExercises\b
  1174. \po1. Using the variables \B\ff<(CG)Courier>absorption\b\ff<(CG)Times>, \B\ff<(CG)Courier>iron\b\ff<(CG)Times> and \B\ff<(CG)Courier>aluminum\b\ff<(CG)Times> introduced in Section 6.1 above construct and examine a model with \B\ff<(CG)Courier>absorption\b\ff<(CG)Times> as the dependent variable.
  1175. 2. Using the variables \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times>, \B\ff<(CG)Courier>tensile-strength\b\ff<(CG)Times> and \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> introduced in Section 6.2 above construct and examine a model with \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times> as the dependent variable.\pn
  1176. <PTXT
  1177. \n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp____________________________________\SP1\Sp
  1178. \SP\pi21\Sp\fs<10>Ordinarily the entries in the lists returned by these messages correspond simply to the intercept, if one is included in the model, followed by the independent variables as they were supplied to \B\ff<(CG)Courier>regression-model\b\ff<(CG)Times>. However, if degeneracy is detected during computations some variables will not be used in the fit; they will be marked as \Ialiased\i in the printed summary. The indices of the variables used can be obtained by the :\ff<(CG)Courier>basis \ff<(CG)Times>message; the entries in the list returned by :\B\ff<(CG)Courier>coef-estimates\b\ff<(CG)Times> correspond to the intercept, if appropriate, followed by the coefficients of the elements in the basis. The messages \B\ff<(CG)Courier>:x-matrix\b\ff<(CG)Times> and \B\ff<(CG)Courier>:xtxinv\b\ff<(CG)Times> are similar in that they use only the variables in the basis.
  1179. JPBOX
  1180. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp43\.
  1181.     TPPAG
  1182. wPBOX
  1183. ]PTXT
  1184. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp44\.
  1185. &"PBOX
  1186. )rPBOX
  1187. -sPBOX
  1188. /\n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp____________________________________________
  1189. \SP\pi22\SpThe / function is used here with three arguments. The first argument is divided by the second, and the result is then divided by the third. Thus the result of the expression (/ 6 3 2) is 1.\pn
  1190. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp45\.
  1191. BPTXT
  1192. 7\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp^\.
  1193. {PBOX
  1194. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp46\.
  1195. ?PBOX
  1196.     PPAG
  1197. C\n\B\ff<(CG)Times>\fs<14>\jf\ll<1>\ps<100>\t<0>\Fp8   Defining Your Own Functions and Methods\b\fs<12>
  1198. This section gives a brief introduction on how to program XLISP-STAT. The most basic programming operation is to define a new function. Closely related is the idea of defining a new method for an object.\SP23\Sp
  1199. \B8.1  Defining Functions\b
  1200. You can use the XLISP language to define functions of your own. Many of the functions you have been using so far are written in this language. The special form used for defining functions is called \B\ff<(CG)Courier>defun\b\ff<(CG)Times>. The simplest form of the \B\ff<(CG)Courier>defun\b\ff<(CG)Times> syntax is
  1201. \B\ff<(CG)Courier>(defun fun args expression)\b\ff<(CG)Times>
  1202. where \B\ff<(CG)Courier>fun\b\ff<(CG)Times> is the symbol you want to use as the function name, \B\ff<(CG)Courier>args\b\ff<(CG)Times> is the list of the symbols you want to use as arguments and \B\ff<(CG)Courier>expression\b\ff<(CG)Times> is the body of the function. Suppose for example that you want to define a function to delete a case from a list. This function should take as its arguments the list and the index of the case you want to delete.  The body of the function can be based on either of the two approaches described in Section 4.3 above. Here is one approach:
  1203. \B\ff<(CG)Courier>(defun delete-case (x i)
  1204.   \s(select x (remove i (iseq 0 (- (length x) 1))) ) )\b\ff<(CG)Times>
  1205. I have used the function \B\ff<(CG)Courier>length\b\ff<(CG)Times> in this definition to determine the length of the argument \B\ff<(CG)Courier>x\b\ff<(CG)Times>. Note that none of the arguments to \B\ff<(CG)Courier>defun\b\ff<(CG)Times> are quoted: \B\ff<(CG)Courier>defun\b\ff<(CG)Times> is a special form that does not evaluate its arguments.
  1206. \piUnless the functions you define are very simple you will probably want to define them in a file and load the file into XLISP-STAT with the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command. You can put the functions in the \B\ff<(CG)Courier>statinit.lsp\b\ff<(CG)Times> file or include in \B\ff<(CG)Courier>statinit.lsp \b\ff<(CG)Times>a \B\ff<(CG)Courier>load\b\ff<(CG)Times> command that will load another file.  The version of XLISP-STAT for the Macintosh includes a simple editor that can be used from within XLISP-STAT. The editor is described briefly in Section 5.6 above.
  1207. You can also write functions that send messages to objects. Here is a function that takes two regression models, assumed to be nested, and \pncomputes the \IF\i statistic for comparing these models:
  1208. \B\ff<(CG)Courier>(defun f-statistic (m1 m2)
  1209. "Args: (m1 m2)
  1210. Computes the F statistic for testing model m1 within model m2."
  1211.   \s(let ((send ss1 (m1 :sum-of-squares))
  1212.         \s\s (send df1 (m1 :df))
  1213.         \s\s (send ss2 (m2 :sum-of-squares))
  1214.         \s\s (send df2 (m2 :df)))
  1215.     \s (/ (/ (- ss1 ss2) (- df1 df2)) (/ ss2 df2))))\b\ff<(CG)Times>
  1216. This definition uses the Lisp \B\ff<(CG)Courier>let\b\ff<(CG)Times> construct to establish some local \Ivariable bindings\i. The variables \B\ff<(CG)Courier>ss1\b\ff<(CG)Times>,  \B\ff<(CG)Courier>df1\b\ff<(CG)Times>, \B\ff<(CG)Courier>ss2\b\ff<(CG)Times> and \B\ff<(CG)Courier>df2\b\ff<(CG)Times> are defined in terms of the two model arguments \B\ff<(CG)Courier>m1\b\ff<(CG)Times> and \B\ff<(CG)Courier>m2\b\ff<(CG)Times>, and are then used to compute the \IF\i statistic. The string following the argument list is a \Idocumentation string\i. When a documentation string is present in a \B\ff<(CG)Courier>defun\b\ff<(CG)Times> expression \B\ff<(CG)Courier>defun\b\ff<(CG)Times> will install it so the \B\ff<(CG)Courier>help\b\ff<(CG)Times> function will be able to retrieve it.
  1217. \B8.2  Anonymous Functions\b
  1218. Suppose you would like to plot the function \If\i(\Ix\i) = 2\Ix\i + \Ix\i\SP2\Sp over the range -2 \ff<(CG)Symbol>
  1219. \ff<(CG)Times> \Ix\i \ff<(CG)Symbol>
  1220. \ff<(CG)Times> 3. We can do this by first defining a function \B\ff<(CG)Courier>f\b\ff<(CG)Times> and then using \B\ff<(CG)Courier>plot-function\b\ff<(CG)Times>:
  1221. \ll<-2>
  1222. \B\ff<(CG)Courier>(defun f (x) (+ (* 2 x) (^ x 2)))\ll<1>
  1223. (plot-function #'f -2 3)\b\ff<(CG)Times>\ll<-2>
  1224. \ll<1>
  1225. This is not too hard, but it nevertheless involves one unnecessary step: naming the function \B\ff<(CG)Courier>f\b\ff<(CG)Times>. You probably won't need this function again; it is a throw away function defined only to allow you to give it to \B\ff<(CG)Courier>plot-function\b\ff<(CG)Times> as an argument. It would be nice if you could just give \B\ff<(CG)Courier>plot-function\b\ff<(CG)Times> an expression that constructs the function you want. Here is such an expression:
  1226. \ll<-2>
  1227. \B\ff<(CG)Courier>(function (lambda (x) (+ (* 2 x) (^ x 2))))\b\ff<(CG)Times>
  1228. \ll<1>
  1229. There are two steps involved. The first is to specify the definition of your function. This is done using a\I lambda expression\i, in this case 
  1230. \ll<-2>
  1231. \B\ff<(CG)Courier>(lambda (x) (+ (* 2 x) (^ x 2)))\b\ff<(CG)Times>
  1232. \ll<1>
  1233. A lambda expression is a list starting with the symbol \B\ff<(CG)Courier>lambda\b\ff<(CG)Times>, followed by the list of arguments and the expressions making up the body of the function. The lambda expression is only a definition, it is not yet a function, a piece of code that can be applied to arguments. The special form \B\ff<(CG)Courier>function\b\ff<(CG)Times> takes the lambda list and constructs such a function. The result can be saved in a variable or it can be passed on to another function as an argument. For our plotting problem you can use the single expression
  1234. \ll<-2>
  1235. \B\ff<(CG)Courier>(plot-function (function (lambda (x)\ll<-4> (+ (* 2 x) (^ x 2)))) -2 3)\b\ff<(CG)Times>\ll<-1>
  1236. \ll<1>
  1237. or, using the \B\ff<(CG)Courier>#'\b\ff<(CG)Times> short form,
  1238. \ll<-2>
  1239. \B\ff<(CG)Courier>(plot-function #'(lambda (x) (+ (* 2 x) (^ x 2))) -2 3)\b\ff<(CG)Times>
  1240. \ll<1>
  1241. Since the function used in these expressions is never named it is sometimes called an \Ianonymous function\i.
  1242. You can also construct a rotating plot of a function of two variables using the function \B\ff<(CG)Courier>spin-function\b\ff<(CG)Times>. As an example, the expression
  1243. \ll<-2>
  1244. \B\ff<(CG)Courier>(spin-function #'(lambda (x y) (+ (^ x 2) (^ y 2))) -1 1 -1 1)\b\ff<(CG)Times>
  1245. \ll<1>
  1246. constructs a plot of the function \If\i(\Ix\i,\I y\i) = \Ix\i\SP2\Sp + \Iy\i\SP2\Sp over the range -1\ff<(CG)Symbol> 
  1247. \ff<(CG)Times> \Ix\i \ff<(CG)Symbol>
  1248. \ff<(CG)Times> 1, -1\ff<(CG)Symbol>
  1249. \ff<(CG)Times> \Iy\i \ff<(CG)Symbol>
  1250. \ff<(CG)Times> 1 using a 6 x 6 grid.
  1251. \piThe number of grid points can be changed using the \B\ff<(CG)Courier>:num-points\b\ff<(CG)Times> keyword. The result is shown in Figure 17. Again it convenient to use a lambda expression to specify the function to be plotted. There are a number of situations in which you might want to pass a function on as an argument without first going through the trouble of thinking up a name for the function and defining it using defun. A few additional examples are given in the next subsection.\pn
  1252. \B8.3  Some Dynamic Simulations\b
  1253. In Section 6.6 we used a loop to control a dynamic simulation in which points in a histogram of one variable were selected and deselected in the order of a second variable. Let's look at how to run the same simulation using a \Islider\i to control the simulation. 
  1254. \piA slider is a modeless dialog box containing a scroll bar and a value display field. As the scroll bar is\pn moved the displayed value is changed and an action is taken. The action is defined by an \Iaction function\i given to the scroll bar, a function that is called with one value, the current slider value, each time the value is changed by the user. There are two kinds of sliders, sequence sliders and
  1255.  \jcFigure 17: Rotatable plot of\I f\i(\Ix\i,\Iy\i) = \Ix\i\SP2\Sp + \Iy\i\SP2\Sp\ll<-2>.\jf
  1256. \ll<1>
  1257. interval sliders. Sequence sliders take a sequence (a list or a vector) and scroll up and down the sequence. The displayed value is either the current sequence element or the corresponding element of a display sequence. An interval slider dialog takes an interval, divides it into a grid and scrolls through the grid. By default a grid of around 30 points is used; the exact number and the interval end points are adjusted to give nice printed values. The current interval point is displayed in the display field.
  1258. \piFor our example lets use a sequence slider to scroll through the elements of the \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> list in order and select the corresponding element of \B\ff<(CG)Courier>abrasion-loss\b\ff<(CG)Times>. The expression \pn
  1259. \ll<-2>
  1260. \B\ff<(CG)Courier>(def h (histogram abrasion-loss))\b\ff<(CG)Times>
  1261. \ll<1>
  1262. sets up a histogram and saves its plot object in the variable \B\ff<(CG)Courier>h\b\ff<(CG)Times>. The function \B\ff<(CG)Courier>sequence-slider-dialog\b\ff<(CG)Times> takes a list or vector and opens a sequence slider to scroll through its argument. To do something useful with this dialog we need to give it an action function as the value of the keyword argument \B\ff<(CG)Courier>:action\b\ff<(CG)Times>. The function should take one argument, the current value of the sequence controlled by the slider. The expression
  1263.  \ll<-2>
  1264. \B\ff<(CG)Courier>(sequence-slider-dialog (order hardness) :action\ll<1>
  1265.                         \s\s\s\s\s#'(lambda (i)
  1266.                             \s\s\s\s\s\s(send h :unselect-all-points)
  1267.                             \s\s\s\s\s\s(send h :point-selected i t)))\b\ff<(CG)Times>\ll<-2>
  1268. \ll<1>
  1269. sets up a slider for moving the selected point in the \B\ff<(CG)Courier>abrasion-loss\ff<(CG)Times> \bhistogram along the order of the \B\ff<(CG)Courier>hardness\b\ff<(CG)Times> variable. The histogram and scrollbar are shown in Figure 18. The action function is called every time the slider is moved. It is called with the current element of the sequence \B\ff<(CG)Courier>(order hardness)\b\ff<(CG)Times>, the index of the point to select. It clears all current selections and then selects the point specified in the call from the slider. The body of the function is almost identical to the body of the \B\ff<(CG)Courier>dotimes\b\ff<(CG)Times> loop used in Section 6.6. The slider is thus an interactive, graphically controlled version of this loop.
  1270. \jcFigure 18: Slider-controlled animation of a histogram.\jf
  1271. \piAs another example, suppose we would like to examine the effect of changing the exponent in a Box-Cox power transformation\pn
  1272. \s\s\s \s  \ll<-4>  x\SP\ff<(CG)Symbol>l\Sp\ff<(CG)Times> - 1 \sif \ff<(CG)Symbol>l 
  1273. \ff<(CG)Times> 0\ll<-3>
  1274. \s\s\s\s    \SP______\Sp\ll<-6>
  1275. \s\s\s\ll<1>h(x) =\ll<-6>\s  \ll<-8>     \ff<(CG)Symbol>l\ff<(CG)Times>\ll<1>
  1276. \s\s\s\s    log(\Ix\i) \sotherwise
  1277. on a probability plot. As a first step we might define a function to compute the power transformation and normalize the result to fall between zero and one:
  1278. \B\ff<(CG)Courier>(defun bc (x p)
  1279.   \s(let* ((bcx (if (< (abs p) .0001) (log x) (/ (^ x p) p)))
  1280.          \s\s  (min (min bcx))
  1281.          \s\s  (max (max bcx)))
  1282.     \s(/ (- bcx min) (- max min))))\b\ff<(CG)Times>
  1283. This definition uses the \B\ff<(CG)Courier>let*\b\ff<(CG)Times> form to establish some local variable bindings. The \B\ff<(CG)Courier>let*\b\ff<(CG)Times> form is like the \B\ff<(CG)Courier>let\b\ff<(CG)Times> form used above except that \B\ff<(CG)Courier>let*\b\ff<(CG)Times> defines its variables sequentially, allowing a variable to be defined in terms of other variables already defined in the \B\ff<(CG)Courier>let*\b\ff<(CG)Times> expression. In this case the variables \B\ff<(CG)Courier>min\b\ff<(CG)Times> and \B\ff<(CG)Courier>max\b\ff<(CG)Times> are defined in terms of the variable \B\ff<(CG)Courier>bcx\b\ff<(CG)Times>. 
  1284. \piNext we need a set of positive numbers to transform. Let's use a sample of thirty observations from a \ff<(CG)Symbol>c\SB\t<-1>4\Sb\ff<(CG)Times>\t<-4>2\t<0> distribution and order the observations\pn
  1285. \B\ff<(CG)Courier>(def x (sort-data (chisq-rand 30 4)))\b\ff<(CG)Times>
  1286. The normal quantiles of the expected uniform order statistics are given by
  1287. \B\ff<(CG)Courier>(def r (normal-quant (/ (iseq 1 30) 31)))\b\ff<(CG)Times>
  1288. and a probability plot of the untransformed data is constructed using
  1289. \ll<-2>
  1290. \B\ff<(CG)Courier>(def myplot (plot-points r (bc x 1)))\b\ff<(CG)Times>
  1291. \ll<1>
  1292. Since the power used is 1 the function \B\ff<(CG)Courier>bc\b\ff<(CG)Times> just rescales the data.
  1293. \piThere are several ways to set up a slider dialog to control the power parameter. The simplest approach is to use the function \B\ff<(CG)Courier>interval-slider-dialog\b\ff<(CG)Times>:\pn
  1294. \B\ff<(CG)Courier>(interval-slider-dialog (list -1 2)
  1295.                         \s\s\s\s\s:points 20
  1296.                         \s\s\s\s\s:action #'(lambda (p)
  1297.                                    \s\s\s\s\s\s(send myplot :clear nil)
  1298.                                    \s\s\s\s\s\s(send\t<-1> \t<0>myplot\t<-2> \t<0>:add-points r (bc x p))))\b\ff<(CG)Times>
  1299. \B\ff<(CG)Courier>interval-slider-dialog\b\ff<(CG)Times> takes a list of two numbers, the lower and upper bound of an interval. The action function is called with the current position in the interval.
  1300. \piThis approach works fine on a Mac II but may be a bit slow on a Mac Plus or a Mac SE. An alternative is to precompute the transformations for a list of powers and then use the precomputed values in the display. For example, using the powers defined in\pn
  1301. \B\ff<(CG)Courier>(def powers (rseq -1 2 16))\b\ff<(CG)Times>
  1302. we can compute the transformed data for each power and save the result as the variable \B\ff<(CG)Courier>xlist\b\ff<(CG)Times>:
  1303. \B\ff<(CG)Courier>(def xlist (mapcar #'(lambda (p) (bc x p)) powers))\b\ff<(CG)Times>
  1304. The function \B\ff<(CG)Courier>mapcar\b\ff<(CG)Times> is one of several \Imapping functions \iavailable in Lisp. The first argument to \B\ff<(CG)Courier>mapcar\b\ff<(CG)Times> is a function. The second argument is a list. \B\ff<(CG)Courier>mapcar\b\ff<(CG)Times> takes the function, applies it to each element of the list and returns the list of the results\SP24\Sp.  Now we can use a sequence slider to move up and down the transformed values in \B\ff<(CG)Courier>xlist\b\ff<(CG)Times>:
  1305. \ll<-2>
  1306. \B\ff<(CG)Courier>(sequence-slider-dialog xlist\ll<1>
  1307.                         \s\s\s\s\s:display powers
  1308.                         \s\s\s\s\s:action #'(lambda (x)
  1309.                                    \s\s\s\s\s\s(send myplot :clear nil)
  1310.                                    \s\s\s\s\s\s(send myplot :add-points r x)))\b\ff<(CG)Times>\ll<-2>
  1311. \ll<1>
  1312. Note that we are scrolling through a list of lists and the element passed to the action function is thus the list of current transformed values. We would not want to see these values in the display field on the slider, so I have used the keyword argument \B\ff<(CG)Courier>:display\b\ff<(CG)Times> to specify an alternative display sequence, the powers used in the transformation.
  1313. \B8.4  Defining Methods\b
  1314. When a message is sent to an object the object system will use the object and the method selector to find the appropriate piece of code to execute. Different objects may thus respond differently to the same message. A linear regression model and a nonlinear regression model might both respond to a \B\ff<(CG)Courier>:coef-estimates\b\ff<(CG)Times> message but they will execute different code to compute their responses.
  1315. \piThe code used by an object to respond to a message is called a \Imethod\i. Objects are organized in a hierarchy in which objects inherit from other objects. If an object does not have a met\pnhod of its own for responding to a message it will use a method inherited from one of its ancestors. The \B\ff<(CG)Courier>send\b\ff<(CG)Times> function will move up the \Ipredecence list \iof an object's ancestors until a method for a message is found.
  1316. \piMost of the objects encountered so far inherit directly from \Iprototype\i objects. Scatterplots inherit from \B\ff<(CG)Courier>scatterplot-proto\b\ff<(CG)Times>, histograms from \B\ff<(CG)Courier>histogram-proto\b\ff<(CG)Times>, regression models from \B\ff<(CG)Courier>regression-model-proto\b\ff<(CG)Times>. Prototypes are just like any other object. They are essentially \Itypical\i versions of a certain kind of object that define default behavior. Almost all methods are owned by prototypes.  But any object can own a method, and in the process of debugging a new method it is often better to attach the method to a separate object constructed for that purpose instead of the prototype.
  1317. To add a method to an object you can use the \B\ff<(CG)Courier>defmeth\b\ff<(CG)Times> macro. As an example, in Section 7 we calculated Cook's distances for a regression model. If you find that you are doing this very frequently then you might want to define a \B\ff<(CG)Courier>:cooks-distances\b\ff<(CG)Times> method. The general form of a method definition is:\pn
  1318. \B\ff<(CG)Courier>(defmeth object :new-method arg-list body)\b\ff<(CG)Times>
  1319. \B\ff<(CG)Courier>object\b\ff<(CG)Times> is the object that is to own the new method. In the case of regression models this can be either a specific regression model  or the prototype that all regression models inherit from, \B\ff<(CG)Courier>regression-model-proto\b\ff<(CG)Times>. The argument \B\ff<(CG)Courier>:new-method\b\ff<(CG)Times> is the message selector for your method; in our case this would be \B\ff<(CG)Courier>:cooks-distances\b\ff<(CG)Times>. The argument \B\ff<(CG)Courier>arg-list\b\ff<(CG)Times> is the list of argument names for your method, and \B\ff<(CG)Courier>body\b\ff<(CG)Times> is one or more expressions making up the body of the method. When the method is used each of these expressions will be evaluated, in the order in which they appear. 
  1320. \piHere is an expression that will install the\B \ff<(CG)Courier>:cooks-distances\b\ff<(CG)Times> method:\pn
  1321. \B\ff<(CG)Courier>(defmeth regression-model-proto :cooks-distances ()
  1322. "Message args: ()
  1323. Returns Cooks distances for the model."
  1324.   \s(let* ((leverages (send self :leverages))
  1325.          \s\s  (studres (/ (send self :residuals) 
  1326.                      \s\s\s(* (send self :sigma-hat) (sqrt (- 1 leverages)))))
  1327.          \s\s  (num-coefs (send self :num-coefs)))
  1328.     \s (* (^ studres 2) (/ leverages (- 1 leverages) num-coefs)))))\b\ff<(CG)Times>
  1329. The variable \B\ff<(CG)Courier>self\b\ff<(CG)Times> refers to the object that is receiving the message.
  1330. \B8.5  Plot Methods\b
  1331. All plot activities are accomplished by sending messages to plot objects. For example, every time a plot needs to be redrawn the system sends the plot the \B\ff<(CG)Courier>:redraw\b\ff<(CG)Times> message. By defining a new method for this message you can change the way a plot is drawn. Similarly, when the mouse is moved or clicked in a plot the plot is sent the \B\ff<(CG)Courier>:do-mouse\b\ff<(CG)Times> message. Menu items also send messages to their plots when they are selected. If you are interested in modifying plot behavior you may be able to get started by looking at the methods defined in the graphics files loaded on start up. Further details will be given in [17].
  1332. \B\fs<14>9   Matrices and Arrays\b\fs<12>
  1333. XLISP-STAT includes support for multidimensional arrays patterned after the Common Lisp standard described in detail in Steele [15]. The funcitons supported are listed in Section C.6 of the appendix.
  1334. \piIn addition to the standard Common Lisp array functions XLISP-STAT also includes a number of linear algebra functions such as \B\ff<(CG)Courier>inverse\b\ff<(CG)Times>, \B\ff<(CG)Courier>solve\b\ff<(CG)Times>, \B\ff<(CG)Courier>transpose\b\ff<(CG)Times>, c\B\ff<(CG)Courier>hol-decomp\ff<(CG)Times>,\b l\B\ff<(CG)Courier>u-decomp\b\ff<(CG)Times> and \B\ff<(CG)Courier>sv-decomp\b\ff<(CG)Times>. These functions are list in the appendix as well.
  1335. An array is printed using the standard Common Lisp format. For example, a 2 by 3 matrix with rows (1 2 3) and (4 5 6) is printed as
  1336. \B\ff<(CG)Courier>\pn#2A((1 2 3)(4 5 6))\b\ff<(CG)Times>
  1337. The prefix \B\ff<(CG)Courier>#2A\b\ff<(CG)Times> indicates that this is a two-dimensional array. This form is not particularly readable, but it has the advantage that it can be pasted into expressions and will be read as an array by the XLISP reader.\SP25\Sp For matrices you can use the function \B\ff<(CG)Courier>print-matrix\b\ff<(CG)Times> to get a slightly more readable representation:
  1338. \B\ff<(CG)Courier>> (print-matrix '#2a((1 2 3)(4 5 6)))
  1339. \s(1 2 3)
  1340. \s(4 5 6)
  1341. \T     )
  1342. >\b\ff<(CG)Times>
  1343. \piThe \B\ff<(CG)Courier>select\b\ff<(CG)Times> funciton can be used to extract elements or subarrays from an array. If \B\ff<(CG)Courier>A\b\ff<(CG)Times> is a two dimensional array then the expression
  1344. \B\ff<(CG)Courier>\pn(select a 0 1)\b\ff<(CG)Times>
  1345. will return element 1 of row  0 of \B\ff<(CG)Courier>A\b\ff<(CG)Times>. The expression
  1346. \B\ff<(CG)Courier>(select a (list 0 1)\M(list 0 1))\b\ff<(CG)Times>
  1347. returns the upper left hand corner of \B\ff<(CG)Courier>A\b\ff<(CG)Times>.\pi
  1348. \B\fs<14>10   Nonlinear Regression\b\fs<12>
  1349. XLISP-STAT allows the construction of nonlinear, normal regression models. The present implementation is experimental (even more experimental than the rest of the program). The definitions needed for nonlinear regression are in the file \B\ff<(CG)Courier>nonlin.lsp\b\ff<(CG)Times> on the distribution disk. This file is not loaded automatically at start up; you should load it now, using the \BLoad\b item on the \BFile\b menu or the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command, to carry out the calculations in this section.
  1350. \piAs an example,Bates and Watts [1, A1.3] descrone an experiment on the relation between the velocity of an enzymatic reaction, \Iy\i, and the substrate concentration, \Ix\i. The data for an experiment in which the enzyme was treated with Puromycin are given by\pn
  1351. \ll<-2>
  1352. \B\ff<(CG)Courier>(def\t<-1> \t<0>x1\t<-1> \t<0>(list 0.02 0.02 0.06 0.06 .11 .1\ll<1>1 .22 .22 .56 .56 1.21 1.1))
  1353. (def y1 (list 76 47 97 107 123 139 159 191 201 207 200))\b\ff<(CG)Times>\ll<-2>
  1354. \ll<1>
  1355. The Michaelis-Menten function\ll<-2>
  1356. \ll<1>
  1357. \s\s\s\ff<(CG)Symbol>\s\ff<(CG)Times>\ll<-5> \ff<(CG)Symbol>q\SB\ff<(CG)Times>1\I\Sbx
  1358. \s\s\s\i\ff<(CG)Symbol>\ll<1>h\ff<(CG)Times>(\Ix\i) =\I\ll<-5>\s____\ll<1>
  1359. \s\s\s\s\i\ff<(CG)Symbol>q\SB\ff<(CG)Times>2\Sb+x
  1360. often provides a good model for the dependence of velocity on substrate concentration. Assuming the Michaelis-Menton function as the mean velocity at a given concentration level the function \B\ff<(CG)Courier>f1\b\ff<(CG)Times> defined by 
  1361. \ll<-2>
  1362. \B\ff<(CG)Courier>(defun f1 (b) (/ (* (select b 0) x) (+ (select b 1) x)))\b\ff<(CG)Times>
  1363. \ll<1>
  1364. computes the list of mean response values at the points in \B\ff<(CG)Courier>x1\ff<(CG)Times> \bfor a parameter list \B\ff<(CG)Courier>b\b\ff<(CG)Times>. Using these definitions, which are contained in the file \B\ff<(CG)Courier>puromycin.lsp\b\ff<(CG)Times> in the \B\ff<(CG)Courier>Data\b\ff<(CG)Times> folder of the distribution disk, we can construct a nonlinear regression model using the \B\ff<(CG)Courier>nreg-model\b\ff<(CG)Times> function.
  1365. \piFirst we need initial estimates for the two model parameters. Examining the expression for the Michaelis-Menton mdoel shows that as \Ix\i increases the function approaches an asymptote, \ff<(CG)Symbol>q\SB\ff<(CG)Times>1\Sb. The second parameter, \ff<(CG)Symbol>q\SB\ff<(CG)Times>2\Sb, can be interpolated as the value of \Ix\i at which the function has reached half its asymptotic value. Using these interpretations for the parameters and a plot constructed by the expression
  1366. \pn\ll<-2>
  1367. \B\ff<(CG)Courier>(plot-points x1 y1)
  1368. \ll<1>
  1369. \b\ff<(CG)Times>shown in Figure 19 we can read off reasonable initial estimates of 200 for  \ff<(CG)Symbol>q\SB\ff<(CG)Times>1\Sb and 0.1 for \ff<(CG)Symbol>q\SB\ff<(CG)Times>2\Sb.  The nreg-model function takes the mean function, the response vector and an initial estimate of the parameters, computes more accurate estimates using an iteractive algorithm starting from the initial guess, and prints a summary of the results. It returns a nonlinear regression model object:\SP26\Sp
  1370. \ll<-2>
  1371. \B\ff<(CG)Courier>> (def puromycin (nreg-model #'f1 y1 (list 200 .1)))\ll<1>
  1372. Residual sum of squares:   7964.19
  1373. Residual sum of squares:   1593.16
  1374. Residual sum of squares:   1201.03
  1375. Residual sum of squares:   1195.51
  1376. Residual sum of squares:   1195.45
  1377. Residual sum of squares:   1195.45
  1378. Residual sum of squares:   1195.45
  1379. Residual sum of squares:   1195.45
  1380. Least Squares Estimates:
  1381. \b\ff<(CG)Times>\jcFigure 19: Plot of reaction veloctiy against substrate concentration for Puromycin experiment
  1382. \B\ff<(CG)Courier>\jf
  1383. Parameter  0:           212.684   (6.94715)
  1384. Parameter  1:         0.0641213   (0.00828094)
  1385. R Squared:             0.961261
  1386. Sigma hat:          0.004483935
  1387. Number of cases:             12
  1388. Degrees of freedom:          10
  1389. PUROMYCIN
  1390. >\b\ff<(CG)Times>
  1391. The function \B\ff<(CG)Courier>nreg-model\b\ff<(CG)Times> also takes several keyword arguments, including \B\ff<(CG)Courier>:epsilon\b\ff<(CG)Times> to specify a convergence criterion and \B\ff<(CG)Courier>:count-limit\b\ff<(CG)Times>, a limit on the number of iterations. By default these values are .001 and 20, respectively. The algorithm for fitting the model is a simple  Gauss-Newton algorithm with backtracking; derivatives are computed numerically.
  1392. \piTo see how you can analyze the model further you can send \B\ff<(CG)Courier>puromycin\b\ff<(CG)Times> the \B\ff<(CG)Courier>:help\b\ff<(CG)Times> message. The result is very similar to the help information for a linear regression model. The reason for this is simple: nonlinear regression models have been implemented as objects, with the nonlinear regression model prototype \B\ff<(CG)Courier>nreg-model-proto\b\ff<(CG)Times> inheriting from of the linear regression model prototype. The internal data, the method for computing estimates and the method of computing fitted values have been modified, but the other methods remain unchanged. Once the model has been fit the Jacobian of the mean function at the estimated parameter values is used as the \IX\i matrix. In terms of this definition most of the methods for linear regression, such as the methods \B\ff<(CG)Courier>:coef-standard-errors\b\ff<(CG)Times> and \B\ff<(CG)Courier>:leverages\b\ff<(CG)Times>, still make sense, at least as first order asymptotic approximations.\pn
  1393. \piIn addition to the messages for linear regression models a nonlinear regression model can respond to the messages
  1394. \B\ff<(CG)Courier>\pn:COUNT-LIMIT
  1395. :EPSILON
  1396. :MEAN-FUNCTION
  1397. :NEW-INITIAL-GUESS
  1398. :PARAMETER-NAMES
  1399. :THETA-HAT
  1400. :VERBOSE\b\ff<(CG)Times>
  1401. \BExercices
  1402. 1. Examine the residuals of the \B\ff<(CG)Courier>puromycin\b\ff<(CG)Times> model.
  1403. \po2. The file \B\ff<(CG)Courier>puromycin.lsp\b\ff<(CG)Times> also contains data \B\ff<(CG)Courier>x2\b\ff<(CG)Times> and \B\ff<(CG)Courier>y2\b\ff<(CG)Times> and mean function \B\ff<(CG)Courier>f2\b\ff<(CG)Times> for an experiment run without the Puromycin treatment. Fit a model to this data and compare the results to the experiment with Puromycin.\pn
  1404. \B\fs<14>11   One Way ANOVA\b\fs<12>
  1405. XLISP-STAT allows the construction of normal one way analysis of variance models. The definitions needed are in the file \B\ff<(CG)Courier>oneway.lsp\b\ff<(CG)Times> on the distribution disk. This file is not loaded automatically at start up; you should load it now, using the \BLoad\b item on the  \BFile\b menu or the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command, to carry out the calculations in this section.
  1406. As an example, suppose we would like to model the data on cholesterol levels in rural and urban Guatemalans, examined in Section 3.2, as a one way ANOVA model.  The boxplots we obtained in Section 3.2 showed that the samples were skewed and the center and spread of the urban sample were larger than the center and spread of the rural sample. To compensate for these facts I will use a normal ANOVA model for the logarithms of the data:
  1407. \B\ff<(CG)Courier>> (def cholesterol (oneway-model (list (log urban) (log rural))))
  1408. Least Squares Estimates:
  1409. Group  0:               5.377172   (0.03624821)
  1410. Group  1:               5.099592   (0.03456131)
  1411. R Squared:             0.4343646
  1412. Sigma hat:             0.1621069
  1413. Number of cases:              42
  1414. Degrees of freedom:           40
  1415. Group Mean Square:     0.8071994   (1)
  1416. Error MeanSquare:     0.02627865   (40)
  1417. CHOLESTEROL
  1418. >\b\ff<(CG)Times> 
  1419. The function \B\ff<(CG)Courier>oneway-model\b\ff<(CG)Times> requires one argument, a list of the lists or vectors representing the samples for the different groups. The model \B\ff<(CG)Courier>cholesterol\b\ff<(CG)Times> can respond to all regression messages as well as a few new ones. The new ones are
  1420. \B\ff<(CG)Courier>:BOXPLOTS
  1421. :ERROR-MEAN-SQUARE
  1422. :ERROR-DF
  1423. :GROUP-DF
  1424. :GROUP-MEAN-SQUARE
  1425. :GROUP-NAMES
  1426. :GROUP-SUM-OF-SQUARES
  1427. :GROUPED-DATA
  1428. :STANDARD-DEVIATIONS\b\ff<(CG)Times>
  1429. \B\fs<14>12   Maximization and Maximum Likelihood Estimation   \b\fs<12>
  1430. XLISP-STAT includes two functions for maximizing functions of several variables. The definitions needed are in the file \B\ff<(CG)Courier>maximize.lsp\b\ff<(CG)Times> on the distribution disk. This file is not loaded automatically at start up; you should load it now, using the \BLoad\b item on the \BFile\b menu or the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command, to carry out the calculations in this section. The material in this seciton is somewhat more advanced as it assumes you are familiar with the basic concepts of maximum likelihood estimation.
  1431. \piTwo functions are available for maximization. The first is \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times>, which takes a function and a list or vector representing an initial guess for the location of the maximum and attempts to find the maximum using an algorithm based on Newton's method with backtracking. The algorithm is based on the unconstrained minimization system described in Dennis and Schnabel [10].
  1432. As an example, Cox and Snell [9, Example T] describe data collected on times (in operating hours) between failures of air conditioning units on several aircraft. The data for one of the aircraft can be enterdd as
  1433. \ll<-2>
  1434. \B\ff<(CG)Courier>\pn(\t<-1>def x (90 10 60 186 61 49 14 \ll<1>24 56 20 79 84 44 59 29 118 25 156 310 76
  1435. \s\s26 44 23 62 130 208 70 101 208\ll<-2>)\b\ff<(CG)Times>\t<0>
  1436. \ll<1>
  1437. A simple model for these data might be to assume the times between failures are independent random variables with a common gamma distribution. The density of the gamma distribution can be written as
  1438. \s\s\s\s\s\ll<-2>(\ff<(CG)Symbol>b\ff<(CG)Times>/\ff<(CG)Symbol>m\ff<(CG)Times>)(\ff<(CG)Symbol>b\I\ff<(CG)Times>x\i/\ff<(CG)Symbol>m\ff<(CG)Times>)\SP\ff<(CG)Symbol>b\ff<(CG)Times>-1\Spe\SP-\ff<(CG)Symbol>b\I\ff<(CG)Times>x\i/\ff<(CG)Symbol>m\Sp\ff<(CG)Times>
  1439. \s\s\s\s\s\SP\ll<-7>______________________
  1440. \Sp\s\s\s\s\s\s\ff<(CG)Symbol>G\ff<(CG)Times>(\ff<(CG)Symbol>b\ff<(CG)Times>)\ll<1>
  1441. where \ff<(CG)Symbol>m\ff<(CG)Times> is the mean time between failures and \ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1> is the gamma shape parameter. The log likelihood for the sample is thus given by\ll<-1>
  1442. \s\s\s\s\s\s\s     \SBn\s\s\s  n\Sb\ll<1>
  1443. \s\s\sn[log(\ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1>) - log(\ff<(CG)Symbol>\ll<-2>m\ff<(CG)Times>\ll<1>) - log(\ff<(CG)Symbol>\ll<-7>G\ff<(CG)Times>\ll<1>(\ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1>))]\M+\ff<(CG)Symbol>\fs<14>S\ff<(CG)Times>\fs<12> (\ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1>-1)log(\ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1>x\SBi\Sb/\ff<(CG)Symbol>\ll<-2>m\ff<(CG)Times>\ll<1>) -  \ff<(CG)Symbol>\fs<14>S \fs<12>\ll<-7>b\ff<(CG)Times>\ll<1>x\SBi\Sb/\ff<(CG)Symbol>\ll<-2>m\ff<(CG)Times>\ll<1>
  1444. \s\s\s\s\s\s\s    \SPi=1\s\s\s i=1\Sp\ll<-2>
  1445. \ll<1>
  1446. We can define a Lisp function to evaluate this log likelihood by
  1447. \ll<-2>
  1448. \B\ff<(CG)Courier>(defun gllik (theta)\ll<1>
  1449. \T  (let* ((mu (select theta 0))
  1450. \s(beta (select theta 1))
  1451. \s(n (length x))
  1452. \s(byn (* x (/ beta mu))))
  1453. \T\T\T\T(+ (* n (- (log beata)\M(log mu)\M(log-gamma beta)))
  1454. \s(sum (*\M(- beta 1)\M(log bym)))
  1455. \s(sum (- bym)))))\b\ff<(CG)Times>\ll<-2>
  1456. \ll<1>
  1457. This definition uses the function \B\ff<(CG)Courier>log-gamma\b\ff<(CG)Times> to evaluate \ff<(CG)Symbol>\ll<-7>G\ff<(CG)Times>\ll<1>(\ff<(CG)Symbol>\ll<-7>b\ff<(CG)Times>\ll<1>). The data and function definitions are contained in the file \B\ff<(CG)Courier>aircraft.lsp\b\ff<(CG)Times> in the \B\ff<(CG)Courier>Data\b\ff<(CG)Times> folder of the distribution disk.
  1458. \piClosed form maximum likelhood estimates are not available for the shape parameter of this distribution, but we can use \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times> to compute estimates numerically.\SP27\Sp We need an initial guess to use as a starting value in the maximization. To get initial estimates we can compute the mean and standard deviation of \B\ff<(CG)Courier>x\b\ff<(CG)Times>\pn
  1459. \ll<-2>
  1460. \B\ff<(CG)Courier>> (mean x)\ll<1>
  1461. 83.5172
  1462. > (standard-deviation x)
  1463. 70.8059\b\ff<(CG)Times>
  1464. \s\s\s\s\s         \SB\ll<-5>^\s\s              ^    ^\Sb
  1465. and use the method of moments estimates  \t<-3> \ff<(CG)Symbol>\t<-1>m\ff<(CG)Times>\t<0> = 83.52 and (\ff<(CG)Symbol>m\ff<(CG)Times>/\ff<(CG)Symbol>s\ff<(CG)Times>)\SP2\Sp,\ll<1> calculated as
  1466. \B\ff<(CG)Courier>>\M(^\M(/ (mean x) (standard-deviation x)) 2)\b\ff<(CG)Times>
  1467. Using these starting values we can now maximize the log likelihood function:
  1468. \B\ff<(CG)Courier>> (newtonmax #'gllik (list 83.5 1.4))
  1469. maximizing...
  1470. Iteration 0.
  1471. Criterion value = -155.603
  1472. Iteration 1.
  1473. Criterion value = -155.354
  1474. Iteration 2.
  1475. Criterion value = -155.347
  1476. Iteration 3.
  1477. Criterion value = -155.347
  1478. \t<-1>Reason for termination: gradient size is less than gradient tolerance.\t<0>
  1479. (83.5173 1.67099)\b\ff<(CG)Times>
  1480. Some statust information is printed as the optimization proceeds. You can turn this off by supplying the keyword argument \B\ff<(CG)Courier>:verbose\b\ff<(CG)Times> with value \B\ff<(CG)Courier>NIL\b\ff<(CG)Times>.
  1481. \piYou might want to check that the gradient of the function is indeed close to zero. If you do not have a closed form expression for the gradient you can use \B\ff<(CG)Courier>numgrad\b\ff<(CG)Times> to calculate a numerical approximation. For our example,\pn
  1482. \ll<-2>
  1483. \B\ff<(CG)Courier>> (numgrad #'gllik (list 83.5173 1.\ll<1>67099))
  1484. (-4.0729e-07 -1.25755e-05)\b\ff<(CG)Times>\ll<-2>
  1485. \ll<1>
  1486. The elements of the gradient are indeed close to zero. You can also compute the second derivative, or Hessian, matrix using \B\ff<(CG)Courier>numhess\b\ff<(CG)Times>. Approximate standard errors of the maximum likelihood estimates are given by the square roots of the diagonal entries of the inverse of the negative Hessian matrix at the maximum:
  1487. \ll<-2>
  1488. \B\ff<(CG)Courier>\t<-1>>\M(sqrt (diagonal (inverse (- (numhess #'g\ll<1>llik (list 83.5173 1.67099))))))\t<0>
  1489. (11.9976 0.402648)\b\ff<(CG)Times>\ll<-2>
  1490. \ll<1>
  1491. \piInstead of calculating the maximum using \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times> and then calculating the derivatives separately you can have \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times> return a list of the location of the maximum, the optimal function value, the gradient and the Hessian by supplying the keyword argument \B\ff<(CG)Courier>:return-derivs\b\ff<(CG)Times> as \B\ff<(CG)Courier>T\b\ff<(CG)Times>.\SP28\Sp
  1492. Newton's method assumes a function is twice continuously differentiable. If your function is not smooth or you are having trouble with \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times> for some other reason you might try a second maximization function, \B\ff<(CG)Courier>nelmeadmax\b\ff<(CG)Times>. \B\ff<(CG)Courier>nelmeadmax\b\ff<(CG)Times> takes a function and an initial guess and attempts to find the maximum using the Nelder-Mead simplex method as described in Press, Flannery, Teukolsky and Vetterling [14]. The initial guess can consist of a simplex, a list of \In\i+1 points for an \In\i-dimensional problem, or it can be a single point, represented by a list or vector of \In\i numbers. If you specify a single point you should also use the keyword argument \B\ff<(CG)Courier>:size\b\ff<(CG)Times> to specify as a list or vector of length \In\i the size in each dimension of the initial simplex. This should represent the size of an initial range in which the algorithm is to start its search for a maximum. We can use this method in our gamma example:\pn
  1493. \B\ff<(CG)Courier>>\M(nelmeadmax #'gllik (list 83.5 1.4)\M:size (list 5 .2))
  1494. Value = -155.603
  1495. Value = -155.603
  1496. Value = -155.603
  1497. Value = -155.587
  1498. Value = -155.53
  1499. Value = -155.522
  1500. Value = -155.347
  1501. Value = -155.347
  1502. Value = -155.347
  1503. Value = -155.347
  1504. (83.5181 1.6709)\b\ff<(CG)Times>
  1505. It takes somewhat longer than Newton's method but it does reach the same result.
  1506. \BExercices\b
  1507. \po1. The data set used in this example consists of sets of measurements for ten aircraft. Data for five of the aircraft are contained in the variable failure-times in the file aircraft.lsp. The calculations of this section used the data for the second aircraft. Examine the data for the remaining four aircraft.
  1508. 2. Use maximum likelihood estimation to fit a Weibull model to the data used in this section.
  1509. \B\fs<14>13 Approximate Bayesian Computations\b\fs<12>
  1510. This section describes a set of tools for computing approximate posterior moments and marginal densities in XLISP-STAT. The definitions needed are in the file \B\ff<(CG)Courier>bayes.lsp\b\ff<(CG)Times> on the distribution disk. This file is not loaded automatically at start up; you should load it now, using the \B Load\b item on the \BFile\b menu or the \B\ff<(CG)Courier>load\b\ff<(CG)Times> command, to carry out the calculations in this section. The material in this section is somewhat more advanced as it assumes you are familiar with the basic concepts of Bayesian inference.
  1511. \piThe functions described in this section can be used to compute first and second order approximations to posterior moments and saddlepoint-like approximations to one dimensional marginal posterior densities. The approximations, based primarily on the results in [18, 19, 20], assume the posterior density is smooth and dominated by a single mode. The implementation is experimental and may change in a number of ways in the near future.
  1512. Let's start with a simple example, a data set used to study the relation between survival time (in weeks) of leukemia patients and white blood cell count recorded for the patients at their entry into the study [9, Example U]. The data consists of two groups of patients classified as AG positive and AG negative.\MThe data for the 17 AG positive patients, contained in the file \B\ff<(CG)Courier>leukemia.lsp\b\ff<(CG)Times> in the \B\ff<(CG)Courier>Data\b\ff<(CG)Times> folder on the distribution disk, can be entered as
  1513. \B\ff<(CG)Courier>\t<-1>\pn(def wbc-pos (list 2300 750 4300 2600 6000 10500 10000 17000 5400 7000
  1514. \s\s9400 32000 35000 100000 100000 52000 100000))
  1515. (def times-pos (list 65 156 100 134 16 108 121 4 39 143 56 26 22 1 1 5 65))\b\ff<(CG)Times>\t<0>\pi
  1516. \pnA high white blood cell count indicates a more serious stage of the disease and thus a lower chance of survival.
  1517. \piA model often used for this data assumes the survival times are exponentially distributed with a mean that is log linear in the logarithm of the white blood cell count. For convenience I will scale the white blood cell counts by 10000. That is, the mean survival time for a patient with white blood cell count log(\IWBC\i\SBi\Sb) is\pn
  1518. \s\s\s\s\ff<(CG)Symbol>m\SB\ff<(CG)Times>i\Sb = \ff<(CG)Symbol>q\SB\ff<(CG)Times>0 \Sbexp{-\ff<(CG)Symbol>q\SB\ff<(CG)Times>1\I\Sbx\i\SBi\Sb}
  1519. with x\SBi\Sb = log(\IWBC\i\SBi\Sb/10000). The log likelihood function is thus given by
  1520. \s\s\s \I\SBn\s\s          \i\U\fs<16>1\I\u\fs<12>     n     \ll<-1>     \i\Sb\ff<(CG)Symbol>q\SB\ff<(CG)Times>1\I\Sbx\i\SBi\Sb
  1521. \s\s\s\ff<(CG)Symbol>\fs<14>S \fs<12>q\SB\ff<(CG)Times>1\I\Sbx\i\SBi\Sb - \In\i log(\ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb) - \ff<(CG)Symbol>q\SB\ff<(CG)Times>0 \Sb\ff<(CG)Symbol>\fs<14>S \I\ff<(CG)Times>\fs<12>y\i\SBi\Sbe\ll<1>
  1522. \s\s\s\I\SPi\i=1\s\s                \Ii\i=1\Sp
  1523. with \Iy\i\SBi\Sb representing the survival times. After computing the transformed \IWBC\i variable as
  1524. \B\ff<(CG)Courier>(def transformed-wbc-pos (- (log wbc-pos)\M(log 10000)))\b\ff<(CG)Times>
  1525.  the log likelihood can be computed using the function
  1526. \B\ff<(CG)Courier>(defun llik-pos (theta)
  1527. \T  (let* ((x transformed-wbc-pos)
  1528. \s (y times-pos)
  1529. \s (theta0 (select theta 0))
  1530. \s (theta1 (select theta 1))
  1531. \s (t1x (* theta1 x)))
  1532. \T    (- (sum t1x)
  1533. \s(*\M(length x)\M(log theta0))
  1534. \s(/ (sum (* y (exp t1x)))
  1535. \s    (theta0))))\b\ff<(CG)Times>
  1536. \piI will look at this problem using a vague, improper prior distribution that is constant over the range \ff<(CG)Symbol>q\SB\ff<(CG)Times>i\Sb > 0; thus the log posterior density is equal to the log likelihood constructed above, up to an additive constant. The first step is to construct a Bayes model object using the function \B\ff<(CG)Courier>bayes-model\b\ff<(CG)Times>. This function takes a function for computing the log posterior density and an initial guess for the posterior mode, computes the posterior mode by an iterative method starting with the initial guess, prints a short summary of  the information in the posterior distribution, and returns a model object. We can use the function \B\ff<(CG)Courier>llik-pos\b\ff<(CG)Times> to compute the log posterior density, so all we need is an initial estimate for the posterior mode. Since the model we are using assumes a linear relationship between the logarithm of the mean survival time and the transformed \IWBC\i variable, a linear regression of the logarithm of the survival times on \B\ff<(CG)Courier>transformed-wbc-pos\b\ff<(CG)Times> should provide reasonable estimates. The linear regression gives
  1537. \B\ff<(CG)Courier>\pn> (regression-model transformed-wbc-pos (log times-pos))
  1538. Least Squares Estimates
  1539. Constant\s\s\s  3.54234\s(0.302699)
  1540. Variable 0\s\s\s-0.817801\s(0.214047)
  1541. R Squared:\s\s\s   0.4932
  1542. Sigma hat:\s\s\s  1.23274
  1543. Number of cases:\s\s  17
  1544. Degrees of freedom:\s\s  15\b\ff<(CG)Times>\pi
  1545. \s\s\s\s\pn\s\s     \ll<-3>  \SB^\s\s\s\t<-1> \t<-8> \t<1>^\Sb\t<0>\pi
  1546. \pnso reasonable initial estimates of the mode are \ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb = exp(3.5) and \ff<(CG)Symbol>q\SB\ff<(CG)Times>\ll<1>1\Sb = 0.8. Now we can use these estimates in the \B\ff<(CG)Courier>bayes-model\b\ff<(CG)Times> function:
  1547. \B\ff<(CG)Courier>> (def lk (bayes-model #'llik-pos (list exp 3.5) .8)))
  1548. maximizing...
  1549. Iteration 0.
  1550. Criterion value = -90.8662
  1551. Iteration 0.
  1552. Criterion value = -85.4065
  1553. Iteration 0.
  1554. Criterion value = -84.0944
  1555. Iteration 0.
  1556. Criterion value = -83.8882
  1557. Iteration 0.
  1558. Criterion value = -83.8774
  1559. Iteration 0.
  1560. Criterion value = -83.8774
  1561. Iteration 0.
  1562. Criterion value = -83.8774
  1563. \t<-1>Reason for termination: gradient size is less that gradient tolerance.\t<0>
  1564. First Order Approximations to Posterior Moments:
  1565. Parameter 0\s\s\s 56.8489 (13.9713)
  1566. Parameter 1\s\s\s0.481829\M(0.179694)
  1567. #<Object:\M1565592, prototype = BAYES-MODEL-PROTO>
  1568. >\b\ff<(CG)Times>
  1569. It is possible to suppress the summary information by supplying \B\ff<(CG)Courier>NIL\b\ff<(CG)Times> as the value of the \B\ff<(CG)Courier>:print\b\ff<(CG)Times> keyword argument.
  1570. \piThe summary printed by \B\ff<(CG)Courier>bayes-model\b\ff<(CG)Times> gives first order approximations to the posterior means and standard deviations of the parameters. That is, the means are approximated by the elements of the posterior mode and the standard deviations by the square roots of the diagonal elements of the inverse of the negative Hessian matrix of the log posterior at the mode. These approximations can also be obtained from the model by sending it the \B\ff<(CG)Courier>:1stmoments\b\ff<(CG)Times> message:\pn
  1571. \B\ff<(CG)Courier>> (send lk :1stmoments)
  1572. ((56.8489 0.481829)\M(13.9713 0.179694))\b\ff<(CG)Times>
  1573. The result is a list of two lists, the means and the standard deviations. A slower but more accurate second order approximation is available as well. It can be obtained using the message \B\ff<(CG)Courier>:moments\b\ff<(CG)Times>:
  1574. \B\ff<(CG)Courier>> (send lk :moments)
  1575. ((65.3085 0.485295)\M(17.158 0.186587))\b\ff<(CG)Times>
  1576. Both these messages allow you to compute moments for individual parameters or groups of parameters by specifying an individual parameter index or a list of indices:
  1577. \ll<-2>
  1578. \B\ff<(CG)Courier>> (send lk :moments 0)\ll<1>
  1579. ((65.3085) (17.158))
  1580. > (send lk :moments (list 0 1))>
  1581. ((65.3085 0.485295)\M(17.158 0.186587))\b\ff<(CG)Times>\ll<-2>
  1582. \ll<1>
  1583. \piThe first and second order approximations to the moments of \ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb are somewhat different; in particular the mean appears to be somewhat larger than the mode. This suggests that the posterior distribution of this parameter is skewed to the right. We can confirm this by looking at a plot of the approximate marginal posterior density. The message \B\ff<(CG)Courier>:margin1\b\ff<(CG)Times> takes a parameter index, and a sequence of points at which to evaluate the density and returns as its value a list of the supplied sequence and the approximate density values at these points. This list can be given to plot-lines to produce a plot of the marginal density:
  1584. \ll<-2>
  1585. \B\ff<(CG)Courier>\pn> (plot-lines (send lk :margin1 0 (rseq 30 120 30)))\ll<1>
  1586. #<Object:\M1623804, prototype - SCATTERPLOT-PROTO>\b\ff<(CG)Times>\pi\ll<-2>
  1587. \pn\ll<1>
  1588. The result is shown in Figure 20 and does indeed show some skewness to the right.
  1589. In additioin to examining individual parameters it is also possible to look at the posterior distribution of smooth functions of the parameters.\SP29\Sp For example, you might want to ask what information the data contains about the probability of a patient with \IWBC\i = 50000 surviving a year or more. The probability is given by\ll<-1>
  1590. \s\s\s\s\s\s\ll<-6>  1
  1591. \s\s\s\s\s\s___ e\SP-5\ll<1>2/\ff<(CG)Symbol>m\ff<(CG)Times>(\Ix\i)\Sp
  1592. \s\s\s\s\s\s\ff<(CG)Symbol>m\ff<(CG)Times>(\Ix\i)
  1593. \s\s\s\s\s\s\s\ll<-2>     -\ff<(CG)Symbol>q\SB\ff<(CG)Times>1\I\Sbx\i
  1594. \s\s\s\s\s\s\ff<(CG)Symbol>m\ff<(CG)Times>(\Ix\i) = \ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sbe
  1595. and \Ix\i = log(5), and can be computed by the function
  1596. \B\ff<(CG)Courier>(defun lk-sprob (theta)
  1597. \T   (let* ((time 52.0)
  1598. \s (x (log 5))
  1599. \s (mu (* (select theta 0)\M(exp (- (* (select theta 1)\Mx))))))
  1600. \T    (exp (- (/ time mu)))))\b\ff<(CG)Times>
  1601. \jcFigure 20:\MPlot of marginal posterior density for \ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb.\jf
  1602. \ll<1>This function can be given to the \B\ff<(CG)Courier>:1stmoments\b\ff<(CG)Times>, \B\ff<(CG)Courier>:moments\b\ff<(CG)Times> and \B\ff<(CG)Courier>:marginal\b\ff<(CG)Times> methods to approximate the posterior moments and marginal posterior density of this function. For the moments the results are\ll<-2>
  1603. \B\ff<(CG)Courier>\ll<-4>>\M(send lk :1stmo\ll<-1>ments #'lk-sprob)\ll<2>
  1604. ((0.137189)\M(0.0948248))
  1605. > (send lk :moments #'lk-sprob)
  1606. ((0.184275)\M(0.111182))\b\ff<(CG)Times>\ll<-2>
  1607. \ll<4>
  1608. \ll<1>with the difference again suggesting some positive skewness, and the marginal density produced by the expression
  1609. \ll<-2>
  1610. \B\ff<(CG)Courier>(plot-lines (send lk :marginal #'lk-sprob (rseq .01 .8 30)))\b\ff<(CG)Times>
  1611. \ll<1>
  1612. is shown in Figure 21. Based on this picture the data suggests that this survival probability is almost certainly below 0.5, but it is difficult to make a more precise statement than that.
  1613. \piThe functions described in this section are based on the optimization code described in the previous section. By default derivatives are computed numerically. If you can compute derivatives yourself you can have your log posterior function return a list of the function value and the gradient or a list of the function value, the gradient and the Hessian matrix.\pn
  1614. \BExercises\b
  1615. \po1. To be able to think about prior distributions for the two parameters in this problem we need to try to understand what the parameters represent. The parameter \ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb is fairly easy to understand: it is the mean survival time for patients with \IWBC\i = 10000. The parameter \ff<(CG)Symbol>q\SB\ff<(CG)Times>1\Sb is a little more difficult to think abour. It represents the approximate percent difference in mean survival time for patients with \IWBC\i differing by one percent. Because of the minus sign in the mean relationship, and the expected inverse relation between \IWBC\i and mean survival time, \ff<(CG)Symbol>q\SB\ff<(CG)Times>1 \Sb is expected to be positive.
  1616. \sConsider an informative prior distribution that assumes the two parameters \Ia priori\i independent, takes log(\ff<(CG)Symbol>q\SB\ff<(CG)Times>0\Sb) to be normally distributed with mean log(52) and standard deviation log(2), and \ff<(CG)Symbol>q\SB\ff<(CG)Times>1\Sb to be exponentially distributed with mean \ff<(CG)Symbol>m\ff<(CG)Times> = 5. This prior is designed to represent an opinion that mean survival time at \IWBC\i = 10000 should be around one year, but that guess could easily be off by a factor of two either way. The percentage change in the mean for a one percent change in \IWBC\i should be on the order of one to ten or so. Examine the posterior distribution for this prior and compare your results to the results for the vague prior used above.
  1617. 2. Construct and examine a posterior distribution for the parameters of the gamma model based on the aircraft data of Section 12.\pn
  1618. \B\fs<14>References\b\fs<12>
  1619. \T\po[1] Bates, D.M. and\MWatts, D.G., (1988), \INonlinear Regression Ananlysis and its Applications\i, New York: Wiley.
  1620. \T[2] Becker, Richard A., and Chambers, John M., (1984), \IS: An Interactive Environment for data Analysis and Graphics\i, Belmont, Ca: Wadsworth.
  1621. \T[3] Becker, Richard A., Chambers, John M., and Wilks, Allan R., (1988), \IThe New S Language: A Programming Environment for Data Analysis and Graphics\i,'' Pacific Grove, Ca: Wadsworth.
  1622. \T[4] Becker, Richard A., and William S. Cleveland, (1987), ``Brushing scatterplots'', \ITechnometrics\i, vol. 29, pp.  127-142.
  1623. \T[5] Betz, David, (1985) ``An XLISP Tutorial'', \IBYTE\i, pp 221.
  1624. \T[6] Betz, David, (1988), ``XLISP: An experimental object-oriented programming language,'' Reference manual for XLISP Version 2.0.
  1625. \T[7] Chaloner, Kathryn, and Brant, Rollin, (1988) ``A Bayesian approach to outlier detection and residual analysis'', \IBiometrika\i, vol. 75, pp. 651-660.
  1626. \T[8] Cleveland, W. S. and McGill, M. E., (1988) \IDynamic Graphics for Statistics\i, Belmont, Ca.: Wadsworth.
  1627. \T[9] Cox, D.R. and Snell, E.J. (1981) \IApplied Statistics:\MPrinciples and Examples\i, London: Chapman and Hall.
  1628. [10] Dennis, J.E> and Schnabel, R.B. (1983)\M\INumerical Methods for Unconstrained Optimization and Nonlinear Equations\i, Englewood Cliffs, N.J>:\MPrentice-Hall.
  1629. [11] Devore, J. and Peck, R., (1986), \IStatistics, the Exploration and Analysis of Data\i, St.  Paul, Mn: West Publishing Co.
  1630. [12] McDonald, J. A., (1982), "Interactive Graphics for Data Analysis," unpublished Ph. D. thesis, Stanford University, Department of Statistics.
  1631. [13] Oehlert, Gary W., (1987), ``MacAnova User's Guide,'' Technical Report 493, School of Statistics, University of Minnesota.
  1632. [14] Press, Flannery, Teukolsky and Vetterling, (1988), \INumerical Recipes in C\i, Cambridge: Cambridge University Press.
  1633. [15] Steele, Guy L., (1984), \ICommon Lisp: The Language\i, Digital Press.
  1634. [16] Stuetzle, W., (1987), "Plot windows," \IJ. Amer. Statist. Assoc\i., vol. 82, pp.  466 - 475.
  1635. [17] Tierney, Luke, (1990) \ILISP-STAT An Object-Oriented Environment for Statistical Computing and Dynamic Graphics\i. New York: Wiley.
  1636. [18] Tierney, L. and Kadane, J.B., (1986), "Accurate approximations for posterior moments and marginal densities."\M\IJ. Amer. Statist. Assoc.,\i vol. 81, pp.82-86.
  1637. [19] Tierney, Luke, Kass, Robert, E. and Kadane, Joseph B., (1989), "Fully exponential Laplace approximations to expectations and variances of nonpositive functions." \IJ. Amer. Statist. Assoc.\i to appear.
  1638. [20] Tierney, Luke, Kass, Robert, E. and Kadane, Joseph B., (1989), "Approximate marginal densities for nonlinear functions,"\M\IBiometrika\i, to appear.
  1639. [21] Weisberg, Sanford, (1982), "MULTREG Users Manual," Technical Report 298, School of Statistics, University of Minnesota.
  1640. [22] Winston, Patrick H. and Berthold K. P. Horn, (1988), \ILISP\i, 3rd Ed., New York: Addison-Wesley.\pn
  1641. *PBOX
  1642. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________
  1643. \SP\pi23\SpThe discussion in this section only scratches the surface of what you can do with functions in the XLISP language. To see more examples you can look at the files that are loaded when XLISP-STAT starts up. For more information on options of function definition, macros, etc. see the XLISP documentation and the books on Lisp mentioned in the\pn references.
  1644. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp47\.
  1645. 5PPAG
  1646. 6PBOX
  1647. 5\n\ff<(CG)Times>\fs<12>\ll<1>\ps<100>\t<0>\Fp48\.
  1648. kPBOX
  1649. OPTXT
  1650. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp49\.
  1651. iPBOX
  1652. 0PTXT
  1653. ?\n\ff<(CG)Times>\fs<8>\jf\ll<0>\ps<100>\t<0>\Fp 
  1654. \fs<48>{\.
  1655. KPTXT
  1656. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp50\.
  1657. 3PPAG
  1658. =PBOX
  1659. #PBOX
  1660. \n\B\ff<(CG)Courier>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_______________________________________
  1661. \SP\pi24\Spmapcar\b\ff<(CG)Times> can be given several lists after the function. The function must take as many arguments as there are lists. \B\ff<(CG)Courier>mapcar\b\ff<(CG)Times> will apply the function using the first element of each list, then using the second element, and so on, until one of the lists is exhausted, and return a list of the results.\pn
  1662. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp51\.
  1663. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp52\.
  1664. XPPAG
  1665. wPTXT
  1666. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp53\.
  1667. {PBOX
  1668. \n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp___________________________________________\SP\fs<12>\pi
  1669. \fs<10>25\SpYou should quote an array if you type it in using this form, as the value of an array is not defined.
  1670. SePBOX
  1671. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp54\.
  1672. lFPTXT
  1673. a\n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_________________________________________
  1674. \SP\pi26\SpRecall that the expression \B\ff<(CG)Courier>#'f1\b\ff<(CG)Times> is short for \B\ff<(CG)Courier>(function f1)\b\ff<(CG)Times>  and is used for obtaining the function definition\pn associated with the symbol \B\ff<(CG)Courier>f1\b\ff<(CG)Times>.
  1675. (PPAG
  1676. bPBOX
  1677. FPBOX
  1678. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp55\.
  1679. tPBOX
  1680. ;\n\ff<(CG)Times>\fs<12>\jf\po\ll<1>\ps<100>\t<0>\Fp56\.
  1681. $PPAG
  1682. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp57\.
  1683. '`PTXT
  1684. h\n\B\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp__________________________________
  1685. \SP\pi27\b\SpThe maximizing value for \ff<(CG)Symbol>m\ff<(CG)Times>  is always the sample mean. We could take advantage of this fact and reduce the problem to a one dimensional maximization, but it is simpler  to just maximize over both parameters.\ff<(CG)Courier>\pn
  1686. GPBOX
  1687. WPTXT
  1688. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp58\.
  1689. %PPAG
  1690. VPBOX
  1691. -PBOX
  1692. H\n\ff<(CG)Times>\fs<10>\jf\ll<1>\ps<100>\t<0>\Fp_______________________________________________
  1693. \SP\pi28\SpThe function \B\ff<(CG)Courier>newtonmax\b\ff<(CG)Times> ordinarily uses numerical derivatives in its computations. Occasionally this may not be accurate enough or may take too long. If you have an expression for computing the gradient or the Hessian then you can use these by having your function return a list of the function value and the gradient, or a list of the function value, the gradient and the Hessian matrix, instead of just returning the function value.\pn
  1694. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp59\.
  1695. qPPAG
  1696. ;\n\ff<(CG)Times>\fs<12>\jf\po\ll<1>\ps<100>\t<0>\Fp60\.
  1697. =PTXT
  1698. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp61\.
  1699. (PBOX
  1700. "PBOX
  1701. 8\n\ff<(CG)Times>\fs<12>\jf\ll<1>\ps<100>\t<0>\Fp62\.
  1702. yPBOX
  1703. LPBOX
  1704. 5PTXT
  1705. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp63\.
  1706. \n\ff<(CG)Times>\fs<10>\jf\ll<-2>\ps<100>\t<0>\Fp___________________________________________
  1707. \SP\pi29\SpThe approximation methods assume these functions are twice continuously differentiable; thus they cannot be indicator functions.\SP\pn
  1708. GsPPAG
  1709. IHPBOX
  1710. M!PTXT
  1711. 9\n\ff<(CG)Times>\fs<12>\jf\ll<-2>\ps<100>\t<0>\Fp64\.
  1712. __PPAG
  1713. \n\ff<(CG)Times>\fs<12>\jc\ll<-2>\ps<100>\t<0>\FpFigure 21: Plot of marginal posterior density of the one year survival probability of a patient with \IWBC\i = 50000.\.
  1714. fPBOX
  1715. TPTXT
  1716. ;\n\ff<(CG)Times>\fs<12>\jf\po\ll<1>\ps<100>\t<0>\Fp65\.
  1717. )PPAG
  1718. ;\n\ff<(CG)Times>\fs<12>\jf\po\ll<1>\ps<100>\t<0>\Fp66\.
  1719. KPPAG
  1720.  PTXT
  1721. ;\n\ff<(CG)Times>\fs<12>\jf\po\ll<1>\ps<100>\t<0>\Fp67\.
  1722. W1:WordProc/Texts/Statistics/XLisp_Manual/Fig_1
  1723. W4:Texts/Statistics/XLisp_Manual/Fig_2
  1724. al/Fig_2
  1725. <PBMG
  1726. W1:WordProc/Texts/Statistics/XLisp_Manual/Fig_3
  1727. aPBMG
  1728. W1:WordProc/Texts/Statistics/XLisp_Manual/Fig_4
  1729. W1:WordProc/Texts/Statistics/XLisp_Manual/Fig_5
  1730. W1:WordProc/Texts/Statistics/XLisp_Manual/Fig_6
  1731. W4:Texts/Statistics/XLisp_Manual/Fig_7a
  1732. U\PBMG
  1733. W4:Texts/Statistics/XLisp_Manual/Fig_7b
  1734. W4:Texts/Statistics/XLisp_Manual/Fig_8
  1735. W4:Texts/Statistics/XLisp_Manual/Fig_9
  1736. W4:Texts/Statistics/XLisp_Manual/Fig_10
  1737. W4:Texts/Statistics/XLisp_Manual/Fig_11
  1738. W4:Texts/Statistics/XLisp_Manual/Fig_12
  1739. W4:Texts/Statistics/XLisp_Manual/Fig_13
  1740. 8PBMG
  1741. W4:Texts/Statistics/XLisp_Manual/Fig_14
  1742. W4:Texts/Statistics/XLisp_Manual/Fig_15a
  1743. W4:Texts/Statistics/XLisp_Manual/Fig_15b
  1744. W4:Texts/Statistics/XLisp_Manual/Fig_16
  1745. [PBMG
  1746. W4:Texts/Statistics/XLisp_Manual/Fig_17
  1747. W4:Texts/Statistics/XLisp_Manual/Fig_18
  1748. W4:Texts/Statistics/XLisp_Manual/Fig_19
  1749. W4:Texts/Statistics/XLisp_Manual/Fig_20
  1750. W4:Texts/Statistics/XLisp_Manual/Fig_21
  1751.