(*OBJECT* OBJECT PROTO)
"The root object."
(WINDOW-PROTO  OBJECT PROTO)
"Window prototype."
(GRAPH-WINDOW-PROTO  OBJECT PROTO)
"Basic graphics window prototype."
(GRAPH-PROTO  OBJECT PROTO)
"Basic graphics window prototype."
(SPIN-PROTO  OBJECT PROTO)
"Rotating plot"
(SCATMAT-PROTO  OBJECT PROTO)
"Scatterplot matrix"
(NAME-LIST-PROTO  OBJECT PROTO)
"Name list"
(HISTOGRAM-PROTO  OBJECT PROTO)
"Histogram"
(SCATTERPLOT-PROTO  OBJECT Proto)
"Scatterplot"
+
"Args: (&rest numbers)\nReturns the sum of its arguments.  With no args, returns 0. Vectorized."
-
"Args: (number &rest more-numbers)\nSubtracts the second and all subsequent NUMBERs from the first. With one arg,\nnegates it. Vectorized."
*
"Args: (&rest numbers)\nReturns the product of its arguments. With no args, returns 1. Vectorized."
/
"Args: (number &rest more-numbers)\nDivides the first NUMBER (element-wise) by each of the subsequent NUMBERS.\nWith one arg, returns its reciprocal. Vectorized."
^
"Args: (base-number power-number)\nReturns BASE-NUMBER raised to the power POWER-NUMBER. Vectorized."
**
"Args: (base-number power-number)\nReturns BASE-NUMBER raised to the power POWER-NUMBER. Vectorized."
<
"Args: (&rest numbers)\nReturns T if NUMBERS are in strictly increasing order; NIL otherwise.\nVectorized."
<=
"Args: (&rest numbers)\nReturns T if NUMBERS are in nondecreasing order; NIL otherwise. Vectorized."
=
"Args: (&rest numbers)\nReturns T if NUMBERS are all equal; NIL otherwise. Vectorized."
/=
"Args: (&rest numbers)\nReturns T if NUMBERS no two adjacent numbers are equal; NIL otherwise. Vectorized."
>=
"Args: (&rest numbers)\nReturns T if NUMBERS are in nonincreasing order; NIL otherwise. Vectorized."
>
"Args: (&rest numbers)\nReturns T if NUMBERS are in strictly decreasing order; NIL otherwise. Vectorized."
ABS
"Args: (number)\nReturns the absolute value or modulus of NUMBER. Vectorized."
ACOS
"Args: (number)\nReturns the arc cosine of NUMBER. Vectorized."
ASIN
"Args: (number)\nReturns the arc sine of NUMBER. Vectorized."
ATAN
"Args: (number)\nReturns the arc tangent of NUMBER. Vectorized."
CEILING
"Args: (number)\nReturns the smallest integer(s) not less than or NUMBER. Vectorized."
COMPLEX
"Args: (realpart &optional (imagpart 0))\nReturns a complex number with the given real and imaginary parts."
CONJUGATE
"Args: (number)\nReturns the complex conjugate of NUMBER."
COS
"Args: (radians)\nReturns the cosine of RADIANS. Vectorized."
EXP
"Args: (x)\nCalculates e raised to the power x, where e is the base of natural\nlogarithms. Vectorized."
EXPT
"Args: (base-number power-number)\nReturns BASE-NUMBER raised to the power POWER-NUMBER. Vectorized."
FLOAT
"Args: (number)\nConverts real number to a floating-point number.  If NUMBER is\nalready a float, FLOAT simply returns NUMBER. Vectorized."
FLOOR
"Args: (number)\nReturns the largest integer( not larger than the NUMBER. Vectorized."
IMAGPART
"Args: (number)\nExtracts the imaginary part of NUMBER."
LOG
"Args: (number)\nReturns the natural logarithm(s) of NUMBER. Vectorized."
LOG-GAMMA
"Args: (x)\nReturns the log gamma function of X. Vectorized."
MAX
"Args: (number &rest more-numbers)\nReturns the greatest of its arguments. Vector reducing"
MIN
"Args: (number &rest more-numbers)\nReturns the least of its arguments. Vector reducing"
PHASE
"Args: (number)\nReturns the angle part of the polar representation of a complex number.\nFor non-complex numbers, this is 0."
PMAX
"Args: (&rest items)\nParallel maximum of ITEMS. Vectorized."
PMIN
"Args: (&rest items)\nParallel minimum of ITEMS. Vectorized."
PROD
"Args: (&rest number-data)\nReturns the product of all the elements of its arguments. Returns 1 if there\nare no arguments. Vector reducing."
RANDOM
"Args: (number)\nGenerates a uniformly distributed pseudo-random number between zero (inclusive)\nand NUMBER (exclusive). Vectorized."
REALPART
"Args: (number)\nExtracts the real part of NUMBER."
MOD
"Args: (x y)\nReturns x mod y. Vectorized."
REM
"Args: (x y)\nReturns the remainder of dividing x by y. Vectorized."
ROUND
"Args: (number)\nRounds NUMBER to nearest integer. Vectorized."
SIN
"Args: (radians)\nReturns the sine of RADIANS. Vectorized."
SQRT
"Args: (number)\nReturns the square root of NUMBER. Vectorized."
SUM
"Args: (&rest number-data)\nReturns the sum of all the elements of its arguments. Returns 0 if there\nare no arguments. Vector reducing."
TAN
"Args: (radians)\nReturns the tangent of RADIANS. Vectorized."
TRUNCATE
"Args: (number)\nReturns real NUMBER as an integer, rounded toward 0. Vectorized."
DEF
"Syntax: (def var form)\nVAR is not evaluated and must be a symbol.  Assigns the value of FORM to\nVAR and adds VAR to the list *VARIABLES* of def'ed variables. Returns VAR.\nIf VAR is already bound and the global variable *ASK-ON-REDEFINE*\nis not nil then you are asked if you want to redefine the variable."
ISEQ
"Args: (n &optional m)
With one argumant returns a list of consecutive integers from 0 to N - 1.
With two returns a list of consecutive integers from N to M.
Examples: (iseq 4) returns (0 1 2 3)
          (iseq 3 7)  returns (3 4 5 6 7)
          (iseq 3 -3) returns (3 2 1 0 -1 -2 -3)"
LIST
"Args: (&rest args)\nReturns a list of its arguments"
REPEAT
"\nArgs: (vals times)\nRepeats VALS. If TIMES is a number and VALS is a non-null, non-array atom, a list\nof length TIMES with all elements eq to VALS is returned. If VALS is a list and\nTIMES is a number then VALS is appended TIMES times. If TIMES is a list of numbers\nthen VALS must be a list of equal length and the simpler version of repeat is\nmapped down the two lists.\nExamples: (repeat 2 5)                 returns (2 2 2 2 2)\n          (repeat '(1 2) 3)            returns (1 2 1 2 1 2)\n\t  (repeat '(4 5 6) '(1 2 3))   returns (4 5 5 6 6 6)\n\t  (repeat '((4) (5 6)) '(2 3)) returns (4 4 5 6 5 6 5 6)"
SAMPLE
"Args: (x n &optional (replace nil))
Returns a list of a random sample of size N from sequence X drawn with or
without replacement."
SELECT
"\nArgs: (a &rest indices)\nA can be a list or an array. If A is a list and INDICES is a single number\nthen the appropriate element of A is returned. If  is a list and INDICES is\na list of numbers then the sublist of the corresponding elements is returned.\nIf A in an array then the number of INDICES must match the ARRAY-RANK of A.\nIf each index is a number then the appropriate array element is returned.\nOtherwise the INDICES must all be lists of numbers and the corresponding\nsubmatrix of A is returned. SELECT can be used in setf."
UNDEF
"Args: (symbol)\nIf SYMBOL is a defined variable it is unbound and removed from the list of\ndefined variables and returns SYMBOL."
VECTOR
"Args: ({item}*)\nReturns a vector with ITEMs as elements."
WHICH
"Args: (x)\nX is an array or a list. Returns a list of the indices where X is not NIL."
BETA-CDF
"Args: (x alpha beta)\nReturns the value of the Beta(ALPHA, BETA) distribution function at X.\nVectorized."
BETA-DENS
"Args: (x alpha beta)\nReturns the density at X of the Beta(ALPHA, BETA) distribution. Vectorized."
BETA-QUANT
"Args: (p alpha beta)\nReturns the P-th quantile of the Beta(ALPHA, BETA) distribution. Vectorized."
BINOMIAL-CDF
"Args (x n p)\nReturns value of the Binomial(N, P) distribution function at X. Vectorized."
BINOMIAL-PMF
"Args (k n p)\nReturns value of the Binomial(N, P) pmf function at integer K. Vectorized."
BINOMIAL-QUANT
"Args: (x n p)\nReturns x-th quantile (left continuous inverse) of Binomial(N, P) cdf.\nVectorized."
BINOMIAL-RAND
"Args: (k n p)\nReturns list of K draws from the Binomial(N, P) distribution. Vectorized."
CAUCHY-CDF
"Args: (x)\nReturns the value of the standard Cauchy distribution function at X.\nVectorized."
CAUCHY-DENS
"Args: (x)\nReturns the density at X of the standard Cauchy distribution. Vectorized."
CAUCHY-QUANT
"Args (p)\nReturns the P-th quantile(s) of the standard Cauchy distribution. Vectorized."
CHISQ-CDF
"Args: (x df)\nReturns the value of the Chi-Square(DF) distribution function at X. Vectorized."
CHISQ-DENS
"Args: (x alpha)\nReturns the density at X of the Chi-Square(DF) distribution. Vectorized."
CHISQ-QUANT
"Args: (p df)\nReturns the P-th quantile of the Chi-Square(DF) distribution. Vectorized."
F-CDF
"Args: (x ndf ddf)\nReturns the value of the F(NDF, DDF) distribution function at X. Vectorized."
F-DENS
"Args: (x ndf ddf)\nReturns the density at X of the F(NDF, DDF) distribution. Vectorized."
F-QUANT
"Args: (p ndf ddf)\nReturns the P-th quantile of the F(NDF, DDF) distribution. Vectorized."
GAMMA-CDF
"Args: (x alpha)\nReturns the value of the Gamma(alpha, 1) distribution function at X.\nVectorized."
GAMMA-DENS
"Args: (x alpha)\nReturns the density at X of the Gamma(ALPHA, 1) distribution. Vectorized."
GAMMA-QUANT
"Args: (p alpha)\nReturns the P-th quantile of the Gamma(ALPHA, 1) distribution. Vectorized."
NORMAL-CDF
"Args: (x)\nReturns the value of the standard normal distribution function at X.\nVectorized."
BIVNORM-CDF
"Args: (x y r)\nReturns the value of the standard bivariate normal distribution function \nwith correlation R at (X, Y). Vectorized."
NORMAL-DENS
"Args: (x)\nReturns the density at X of the standard normal distribution. Vectorized."
NORMAL-QUANT
"Args (p)\nReturns the P-th quantile of the standard normal distribution. Vectorized."
ORDER
"Args (x)\nReturns a sequence of the indices of elements in the sequence of numbers\nor strings X in order."
POISSON-CDF
"Args (x mu)\nReturns value of the Poisson(MU) distribution function at X. Vectorized."
POISSON-PMF
"Args (k mu)\nReturns value of the Poisson(MU) pmf function at integer K. Vectorized."
POISSON-QUANT
"Args: (x mu)\nReturns x-th quantile (left continuous inverse) of Poisson(MU) cdf.\nVectorized."
POISSON-RAND
"Args: (k mu)\nReturns list of K draws from the Poisson(MU) distribution. Vectorized."
RANK
"Args (x)\nReturns a sequence with the elements of the list or array of numbers or\nstrings X replaced by their ranks."
SORT-DATA
"Args: (sequence)\nReturns a sequence with the numbers or strings in the sequence X in order."
T-CDF
"Args: (x df)\nReturns the value of the T(DF) distribution function at X. Vectorized."
T-DENS
"Args: (x alpha)\nReturns the density at X of the T(DF) distribution. Vectorized."
T-QUANT
"Args: (p df)\nReturns the P-th quantile of the T(DF) distribution. Vectorized."
UNIFORM-RAND
"Args: (n)\nReturns a list of N uniform random variables from the range (0, 1).\nVectorized."
NORMAL-RAND
"Args: (n)
Returns a list of N standard normal random numbers. Vectorized."
CAUCHY-RAND
"Args: (n)
Returns a list of N standard Cauchy random numbers. Vectorized."
T-RAND
"Args: (n df)
Returns a list of N T(DF) random variables. Vectorized."
F-RAND
"Args: (n ndf ddf)
Returns a list of N F(NDF, DDF) random variables. Vectorized."
GAMMA-RAND
"Args: (n a)
Returns a list of N Gamma(A, 1) random variables. Vectorized."
CHISQ-RAND
"Args: (n df)
Returns a list of N Chi-Square(DF) random variables. Vectorized."
BETA-RAND
"Args: (n a b)
Returns a list of N beta(A, B) random variables. Vectorized."
HISTOGRAM
"Args: (data &key (title "Histogram"))\nOpens a window with a histogram of DATA. TITLE is the window title. The number\nof bins used can be adjusted using the histogram menu. The histogram can be\nlinked to other plots with the link-views command. Returns a plot object."
LINK-VIEWS
"Args: (&rest plots)\nLinks the argument plots: any change in hiliting or visibility of points in\nthe current plot is propagated to the other plots."
NAME-LIST
"Args: (names &key (title "Name List"))\nNAMES is a number or a list of character strings. Opens a window with a list\nof the supplied character strings or entries numbered from 0 to NAMES - 1.\nThis display can be linked to plots with the link-views function. Returns a\nplot object."
PLOT-FUNCTION
"Args: (f xmin xmax &optional (num-points 50))\nPlots function F of one real variable over the range between xmin and xmax.\nThe function is evaluated at NUM-POINTS points."
PLOT-LINES
"Args: (x y &key (title "Line Plot") variable-labels type width color)\nOpens a window with a connected line plot of X vs Y, where X and Y are\ncompound number-data. VARIABLE-LABELS, if supplied, should be lists of\ncharacter strings. TITLE is the window title. The plot can be linked to\nother plots with the link-views command. Returns a plot object."
PLOT-POINTS
"Args: (x y &key (title "Scatter Plot") variable-labels point-labels symbol color)\nOpens a window with a scatter plot of X vs Y, where X and Y are compound\nnumber-data. VARIABLE-LABELS and POINT-LABELS, if supplied, should be lists of\ncharacter strings. TITLE is the window title. The plot can be linked to\nother plots with the link-views command. Returns a plot object."
SCATTERPLOT-MATRIX
"Args: (data &key (title "Spinning Plot") variable-labels point-labels\n                 (scale t))\nDATA is a list of two or more compound number-data objects of equal length.\nOpens a window with a brushable scatter plot matrix of the elements of DATA.\nVARIABLE-LABELS and POINT-LABELS, if supplied, should be lists of character strings.\nTITLE is the window title. If scale is NIL data are assumed to be between -1\nand 1.The plot can be linked to other plots with the link-views command.\nReturns a plot object."
SPIN-PLOT
"Args: (data &key (title "Spinning Plot") variable-labels point-labels\n                 (scale t))\nDATA is a list of three compound number-data objects of equal length. Opens\na window with a rotating plot of the three elements of DATA. VARIABLE-LABELS\nand POINT-LABELS, if supplied, should be lists of character strings. TITLE\nis the window title. If scale is NIL data are assumed to be between -1 and 1.\nThe plot can be linked to other plots with the link-views command. Returns\na plot object."
(GRAPH-PROTO OBJECT :ADD-LINES)
"Method args: (lines &key type (draw t))\nAdds lines to plot. LINES is a list of sequences, the coordinates of the line starts.\nTYPE is normal or dashed. If DRAW is true the new lines are added to the screen."
(GRAPH-PROTO OBJECT :ADD-POINTS)
"Method args: (points &key point-labels (draw t))\nAdds points to plot. POINTS is a list of sequences, POINT-LABELS a list of\nstrings. If DRAW is true the new points are added to the screen."
(GRAPH-PROTO OBJECT :ADJUST-TO-DATA)
"Method args: (&key (draw t))\nSets ranges to the actual range of variables in the original coordinate\nsystem. If DRAW is true sends :RESIZE and :REDRAW messages."
(GRAPH-PROTO OBJECT :APPLY-TRANSFORMATION)
"Method args: (a &key draw)\nApplies matrix A to current transformation. If draw is true the :REDRAW-CONTENT\nmessage is sent."
(GRAPH-PROTO OBJECT :CLEAR)
"\nMessage args: (&optional (draw t))\nClears the plot data. If DRAW is nil the plot is redrawn; otherwise its\ncurrent screen image remains unchanged."
(GRAPH-PROTO OBJECT :CLEAR-LINES)
"Method args: (&key (draw t))\nRemoves all lines from the plot. If DRAW is true the :REDRAW-CONTENT\nmessage is sent."
(GRAPH-PROTO OBJECT :CLEAR-POINTS)
"Method args: (&key (draw t))\nRemoves all points from the plot. If DRAW is true the :REDRAW-CONTENT\nmessage is sent."
(GRAPH-PROTO OBJECT :ERASE-SELECTION)
"Method args: ()\nSets selected points states to invisible and sends :ADJUST-POINT-SCREEN-STATES message."
(GRAPH-PROTO OBJECT :IDLE-ON)
"\nMethod args: (&optional on)\nSets or returns idling state. On means :do-idle method is sent each pass through\nthe event loop."
(GRAPH-PROTO OBJECT :LINKED)
"Method ars: (&optional on)\nSets or retrieves plot's linking state."
(GRAPH-PROTO OBJECT :NUM-LINES)
"Method args: ()\nReturns the number of line starts in the plot."
(GRAPH-PROTO OBJECT :NUM-POINTS)
"Method args: ()\nReturns the number of points in the plot."
(GRAPH-PROTO OBJECT :NUM-VARIABLES)
"Method args: ()\nReturns the number of variables in the plot."
(GRAPH-PROTO OBJECT :POINT-HILITED)
"Method args: (point &optional hilited)\nSets or returns highlighting status (true or NIL) of POINT. Sends \n:ADJUST-POINT-SCREEN-STATES message if states are set. Vectorized."
(GRAPH-PROTO OBJECT :POINT-LABEL)
"Method args: (point &optional label)\nSets or retrieves label of point POINT. Vectorized."
(GRAPH-PROTO OBJECT :POINT-SELECTED)
"Method args: (point &optional selected)\nSets or returns selection status (true or NIL) of POINT. Sends \n:ADJUST-POINT-SCREEN-STATES message if states are set. Vectorized."
(GRAPH-PROTO OBJECT :POINT-SHOWING)
"Method args: (point &optional selected)\nSets or returns visibility status (true or NIL) of POINT. Sends \n:ADJUST-POINT-SCREEN-STATES message if states are set. Vectorized."
(GRAPH-PROTO OBJECT :POINT-SYMBOL)
"Method args: (point &optional symbol)\nSets or retrieves symbol of point POINT. Vectorized."
(GRAPH-PROTO OBJECT :RANGE)
"Method args: (index &optional low high)\nSets or retrieves variable's original coordinate range. Vectorized."
(GRAPH-PROTO OBJECT :ROTATE-2)
"Method args: (var1 var2 angle &key (draw t))\nRotates int the plane of variables with indices VAR1 and VAR2 by ANGLE, in\nradians. sends the :REDRAW-CONTENT message if DRWA is true."
(GRAPH-PROTO OBJECT :SELECTION)
"Method args: ()\nReturn indices of current selection."
(GRAPH-PROTO OBJECT :SHOW-ALL-POINTS)
"Method args: ()\nSets all point states to normal and sends :ADJUST-POINT-SCREEN-STATES message "
(GRAPH-PROTO OBJECT :SHOWING-LABELS)
"Method args: (&optional showing)\nSets or retrieves current labeling state (true or NIL)."
(GRAPH-PROTO OBJECT :TITLE)
"Method args: (&optional string)\nSets or retrieves window title."
(GRAPH-PROTO OBJECT :TRANSFORMATION)
"Method args: (&optional a &key (draw t))\nSets or retrieves transformation. A should be a matrix or NIL. If draw is true\nthe :REDRAW-CONTENT message is sent."
(GRAPH-PROTO OBJECT :VARIABLE-LABEL)
"Method args: (var &optional label)\nSets or returns label for variable with index VAR. Vectorized."
(HISTOGRAM-PROTO OBJECT :ADD-POINTS)
"Method args: (points (draw t))\nAdds points to plot. POINTS is a sequence or a list of sequences. If DRAW is\ntrue the new points are added to the screen."
(HISTOGRAM-PROTO OBJECT :NUM-BINS)
"Method args: (&optional bins &key (draw t))\nSets or retrieves number of bins in the histogram. Sends :REDRAW-CONTENT message\nif DRAW is true."
(NAME-LIST-PROTO OBJECT :ADD-POINTS)
"Method args: (points &key point-labels (draw t))\nAdds points to plot. POINTS is a number or a list of sequences, POINT-LABELS a list of\nstrings. If DRAW is true the new points are added to the screen."
(SCATTERPLOT-PROTO OBJECT :ADD-LINES)
"Method args: (lines &key type (draw t))
or:          (x y  &key point-labels (draw t))
Adds lines to plot. LINES is a list of sequences, the 
coordinates of the line  starts. TYPE is normal or dashed. If
DRAW is true the new lines are added to the screen. For a 2D
plot POINTS can be replaced by two sequences X and Y."
(SCATTERPLOT-PROTO OBJECT :ADD-POINTS)
"Method args: (points &key point-labels (draw t))
or:          (x y  &key point-labels (draw t))
Adds points to plot. POINTS is a list of sequences, 
POINT-LABELS a list of strings. If DRAW is true the new points
are added to the screen. For a 2D plot POINTS can be replaced
by two sequences X and Y."
(SPIN-PROTO OBJECT :ANGLE)
"Method args: (&optional angle)\nSets or retrieves current rotation angle, in radians."
(SPIN-PROTO OBJECT :DO-IDLE)
"Method args: ()\nSends :ROTATE message."
(SPIN-PROTO OBJECT :ROTATE)
"Method args: ()\nRotates once in the current plane by the current angle."
(SPIN-PROTO OBJECT :SHOWING-AXES)
"Method args: (&optional cuing)\nSets or retrieves cuing status (true or NIL)."
%*
"Args: (a b)\nReturns the matrix product of matrices a and b. If a is a vector it is treated\nas a row vector; if b is a vector it is treated as a column vector."
BIND-COLUMNS
"Args (&rest args)\nThe ARGS can be matrices, vectors, or lists. Arguments are bound into a matrix\nalong their columns.\nExample: (bind-columns #2a((1 2)(3 4)) #(5 6)) returns #2a((1 2 5)(3 4 6))"
BIND-ROWS
"Args (&rest args)\nThe ARGS can be matrices, vectors, or lists. Arguments are bound into a matrix\nalong their rows.\nExample: (bind-rows #2a((1 2)(3 4)) #(5 6)) returns #2a((1 2)(3 4)(5 6))"
CHOL-DECOMP
"Args: (a)\nModified Cholesky decomposition. A should be a square, symmetric matrix.\nComputes lower triangular matrix L such that L L^T = A + D where D is a diagonal\nmatrix. If A is strictly positive definite D will be zero. Otherwise D is as\nsmall as possible to make A + D numerically strictly positive definite. Returns\na list (L (max D))."
COLUMN-LIST
"Args: (m)\nReturns a list of the columns of M as vectors"
COPY-ARRAY
"Args: (array)\nReturns a copy of ARRAY with elements eq to the elements of ARRAY."
COPY-LIST
"Args: (list)\nReturns a new copy of LIST."
COPY-VECTOR
"Args: (VECTOR)\nReturns a copy of VECTOR with elements eq to the elements of VECTOR"
COUNT-ELEMENTS
"Args: (number &rest more-numbers)\nReturns the number of its arguments. Vector reducing"
CROSS-PRODUCT
"Args: (x)\nIf X is a matrix returns (%* (TRANSPOSE X) X). If X is a vector returns\n(INNER-PRODUCT X X)."
DETERMINANT
"Args: (m)\nReturns the determinant of the square matrix M."
DIAGONAL
"Args: (x)\nIf X is a matrix, returns the diagonal of X. If X is a sequence, returns a\ndiagonal matrix of rank (length X) with diagonal elements eq to the elements\nof X."
EIGEN
"Args: (a)\nReturns list of list of eigenvalues and list of eigenvectors of square,\nsymmetric matrix A. Third element of result is NIL if algorithm converges.\nIf the algorithm does not converge, the third element is an integer I.\nIn this case the eigenvalues 0, ..., I are not reliable."
IDENTITY-MATRIX
"Args: (n)\nReturns the identity matrix of rank N."
INNER-PRODUCT
"Args: (x y)\nReturns inner product of sequences X and Y."
INVERSE
"Args: (m)\nReturns the inverse of the the square matrix M; signals an error if M is ill\nconditioned or singular"
LU-DECOMP
"Args: (a)\nA is a square matrix of numbers (real or complex). Computes the LU\ndecomposition of A and returns a list of the form (LU IV D FLAG), where\nLU is a matrix with the L part in the lower triangle, the U part in the \nupper triangle (the diagonal entries of L are taken to be 1), IV is a vector\ndescribing the row permutation used, D is 1 if the number of permutations\nis odd, -1 if even, and FLAG is T if A is numerically singular, NIL otherwise.\nUsed bu LU-SOLVE."
LU-SOLVE
"Args: (lu b)\nLU is the result of (LU-DECOMP A) for a square matrix A, B is a sequence.\nReturns the solution to the equation Ax = B. Signals an error if A is singular."
MAKE-SWEEP-MATRIX
"Args: (x y &optional weights)\nX is a matrix, Y and WEIGHTS are sequences. Returns the sweep matrix for the\n(possibly weighted) regression of Y on X."
MAP-ELEMENTS
"Args: (function data &rest more-data)\nFUNCTION must take as many arguments as there are DATA arguments supplied.\nDATA arguments must either all be sequences or all be arrays of the same\nshape. The result is of the same type and shape as the first DATA argument,\nwith elements the result of applying FUNCTION elementwise to the DATA\narguments"
MATMULT
"Args: (a b)\nReturns the matrix product of matrices a and b. If a is a vector it is treated\nas a row vector; if b is a vector it is treated as a column vector."
MATRIXP
"Args: (m)\nReturns T if M is a matrix, NIL otherwise."
MEAN
"Args: (x)
Returns the mean of the elements x. Vector reducing."
OUTER-PRODUCT
"Args: (x y &optional (fcn #'*))\nReturns the generalized outer product of x and y, using fcn. Tat is, the result\nis a matrix of dimension ((length x) (length y)) and the (i j) element of the\nresult is computed as (apply fcn (aref x i) (aref y j))."
PERMUTE-ARRAY
"Args: (a p)\nReturns a copy of the array A permuted according to the permutation P."
QR-DECOMP
"Args: (a &optional pivot)
A is a matrix of real numbers with at least as many rows as columns. Computes
the QR factorization of A and returns the result in a list of the form (Q R).
If PIVOT is true the columns of X are first permuted to place insure the
absolute values of the diagonal elements of R are nonincreasing. In this case
the result includes a third element, a list of the indices of the columns in
the order in which they were used."
RCONDEST
"Args: (a)\nReturns an estimate of the reciprocal of the L1 condition number of an upper\ntriangular matrix a."
ROW-LIST
"Args: (m)\nReturns a list of the rows of M as vectors"
SOLVE
"Args: (a b)\nSolves A x = B using LU decomposition and backsolving. B can be a sequence\nor a matrix."
SV-DECOMP
"Args: (a)\nA is a matrix of real numbers with at least as many rows as columns.\nComputes the singular value decomposition of A and returns a list of the form\n(U W V FLAG) where U and V are matrices whose columns are the left and right\nsingular vectors of A and W is the sequence of singular values of A. FLAG is T\nif the algorithm converged, NIL otherwise."
SWEEP-OPERATOR
"Args: (a indices &optional tolerances)\nA is a matrix, INDICES a sequence of the column indices to be swept. Returns\na list of the swept result and the list of the columns actually swept. (See\nMULTREG documentation.) If supplied, TOLERANCES should be a list of real\nnumbers the same length as INDICES. An index will only be swept if its pivot\nelement is larger than the corresponding element of TOLERANCES."
TRANSPOSE
"Args: (m)\nReturns the transpose of the matrix M."
VECTORP
"Args: (m)\nReturns T if M is a vector, NIL otherwise."
LOAD
"Args: (filename &key (verbose t) (print nil))\nLoads the file named by FILENAME into XLISP. Returns T if load succeeds,\nNIL if file does not exist."
ROOM
"Args: ()\nShows memory allocation statistics. Returns nil."
AND
"Syntax: (and {form}*)\nEvaluates FORMs in order from left to right.  If any FORM evaluates to NIL,\nreturns immediately with the value NIL.  Else, returns the value of the\nlast FORM."
APPEND
"Args: (&rest lists)\nConstructs a new list by concatenating its arguments."
APPLY
"Args: (function &rest args)\nConses all arguments but the last onto the last and applies FUNCTION to \nthe resulting argument list. Last argument must be a list."
APROPOS
"Args: (string)\nPrints symbols whose print-names contain STRING as substring.\nIf STRING is a symbol its print name is used."
ASSOC
"Args: (item alist &key (test #'eql) test-not)\nReturns the first pair in ALIST whose car is equal (in the sense of TEST) to\nITEM."
ATOM
"Args: (x)\nReturns T if X is not a cons; NIL otherwise."
CAR
"Args: (list)\nReturns the car of LIST.  Returns NIL if LIST is NIL."
CASE
"Syntax: (case keyform {({key | ({key}*)} {form}*)}*)\nEvaluates KEYFORM and tries to find the KEY that is EQL to the value of\nKEYFORM.  If one is found, then evaluates FORMs that follow the KEY and\nreturns the value of the last FORM.  If not, simply returns NIL."
CDR
"Args: (list)\nReturns the cdr of LIST.  Returns NIL if LIST is NIL."
CLOSE
"Args: (stream)\nClose file stream STREAM."
COERCE
"Args: (x type)\nCoerces X to an object of the type TYPE."
COND
"Syntax: (cond {(test {form}*)}*)\nEvaluates each TEST in order until one evaluates to a non-NIL value.  Then\nevaluates the associated FORMs in order and returns the value of the last\nFORM.  If no forms follow the TEST, then returns the value of the TEST.\nReturns NIL, if all TESTs evaluate to NIL."
CONS
"Args: (x y)\nReturns a new cons (list node) whose car and cdr are X and Y, respectively."
CONSP
"Args: (x)\nReturns T if X is a cons; NIL otherwise."
DEFUN
"Syntax: (defun name lambda-list [doc] {form}*)\nDefines a function as the global definition of the symbol NAME. The\ncomplete syntax of a lambda-list is:\n\t({var}*\n\t [&optional {var}*]\n\t [&rest var]\n\t [&aux {var}*])\nThe doc-string DOC, if supplied, is saved as a FUNCTION doc and can be\nretrieved by (documentation 'NAME 'function)."
DO
"Syntax: (do ({(var [init [step]])}*) (endtest {result}*) {tag | statement}*)\nCreates a NIL block, binds each VAR to the value of the corresponding INIT,\nand then executes STATEMENTs repeatedly until ENDTEST is satisfied.  After\neach iteration, assigns to each VAR the value of the corresponding STEP.  When\nENDTEST is satisfied, evaluates RESULTs as a PROGN and returns the value of\nthe last RESULT (or NIL if no RESULTs are supplied).  Performs variable\nbindings and assignments all at once, just like LET does."
DO*
"Syntax: (do* ({(var [init [step]])}*) (endtest {result}*) {tag | statement}*)\nJust like DO, but performs variable bindings and assignments in serial, just\nlike LET* and SETQ do."
DOLIST
"Syntax: (dolist (var listform [result]) {tag | statement}*)\nExecutes STATEMENTs, with VAR bound to each member of the list value of\nLISTFORM.  Then returns the value of RESULT (which defaults to NIL)."
DOTIMES
"Syntax: (dotimes (var countform [result]) {tag | statement}*)\nExecutes STATEMENTs, with VAR bound to each number between 0 (inclusive) and\nthe value of COUNTFORM (exclusive).  Then returns the value of RESULT\n(which defaults to NIL)."
ELT
"Args: (a &rest indices)\nReturns element I of sequence A. ELT can be used in setf."
EQ
"Args: (x y)\nReturns T if X and Y are the same identical object; NIL otherwise."
EQL
"Args: (x y)\nReturns T if X and Y are EQ, or if they are numbers of the same type with\nthe same value, or if they are identical strings.  Returns NIL otherwise."
EQUAL
"Args: (x y)\nReturns T if X and Y are EQL or if they are of the same type and corresponding\ncomponents are EQUAL.  Returns NIL otherwise. Arrays must be EQ to be EQUAL."
EQUALP
"Args: (x y)\nReturns T if (equal x y), or x, y are numbers and (= x y), or\nx and y are strings and (string-equal x y)."
FORMAT
"Args: (destination control &rest args)\nVery basic implementation of Common Lisp format function. Only A, S, D, F, E,\nG, %, and ~ directives are supported. D, % and ~ can take one argument, R, E\nand G can take two."
FUNCALL
"Args: (function &rest arguments)\nApplies FUNCTION to the ARGUMENTs"
IF
"Syntax: (if test then [else])\nIf TEST evaluates to non-NIL, then evaluates THEN and returns the result.\nIf not, evaluates ELSE (which defaults to NIL) and returns the result."
LAST
"Args: (list)\nReturns the last cons in LIST"
LENGTH
"Args: (sequence)\nReturns the length of SEQUENCE."
LET
"Syntax: (let ({var | (var [value])}*) {form}*)\nInitializes VARs, binding them to the values of VALUEs (which defaults to NIL)\nall at once, then evaluates FORMs as a PROGN."
LET*
"Syntax: (let* ({var | (var [value])}*) {form}*)\nInitializes VARs, binding them to the values of VALUEs (which defaults to NIL)\nfrom left to right, then evaluates FORMs as a PROGN."
LISTP
"Args: (x)\nReturns T if X is either a cons or NIL; NIL otherwise."
MAP
"Args: (result-type function sequence &rest more-sequences)\nFUNCTION must take as many arguments as there are sequences provided. RESULT-TYPE\nmust be the either the symbol VECTOR or the symbol LIST. The result is a \nsequence of the specified type such that the i-th element of the result is the\nresult of applying FUNCTION to the i-th elements of the SEQUENCEs."
MAPCAR
"Args: (fun list &rest more-lists)\nApplies FUN to successive cars of LISTs and returns the results as a list."
MEMBER
"Args: (item list &key (test #'eql) test-not)\nReturns the tail of LIST beginning with the first ITEM."
NTH
"Args: (n list)\nReturns the N-th element of LIST, where the car of LIST is the zero-th\nelement."
NTHCDR
"Args: (n list)\nReturns the result of performing the CDR operation N times on LIST."
NULL
"Args: (x)\nReturns T if X is NIL; NIL otherwise."
NUMBERP
"Args: (x)\nReturns T if X is any kind of number; NIL otherwise."
OBJECTP
"Args: (x)\nReturns T if X is an object, NIL otherwise."
OR
"Syntax: (or {form}*)\nEvaluates FORMs in order from left to right.  If any FORM evaluates to\nnon-NIL, quits and returns that value.  If the last FORM is reached,\nreturns whatever value it returns."
PRIN1
"Args: (object &optional (stream *standard-output*))\nPrints OBJECT in the most readable representation.  Returns OBJECT."
PRINC
"Args: (object &optional (stream *standard-output*))\nPrints OBJECT without escape characters.  Returns OBJECT."
PRINT
"Args: (object &optional (stream *standard-output*))\nOutputs a newline character, and then prints OBJECT in the most readable\nrepresentation.  Returns OBJECT."
REMOVE
"Args: (item list &key (test #'eql) test-not)\nReturns a copy of LIST with ITEM removed."
RETURN
"Syntax: (return [result])\nReturns from the lexically surrounding PROG construct.  The value of RESULT,\nwhich defaults to NIL, is returned as the value of the PROG construct."
REVERSE
"Args: (list)\nReturns a new list containing the same elements as LIST but in\nreverse order."
SETF
"Syntax: (setf {place newvalue}*)\nReplaces the value in PLACE with the value of NEWVALUE, from left to right.\nReturns the value of the last NEWVALUE.  Each PLACE may be any one of the\nfollowing:\n  * A symbol that names a variable.\n  * A function call form whose first element is the name of the following\n    functions:\n\tnth\n\taref subarray sublist select elt\n\tget\n\tsymbol-value\n\tsymbol-plist\n\tdocumentation\n\tslot-value\n\tc?r\tc??r\tc???r\tc????r\n    where '?' stands for either 'a' or 'd'."
SETQ
"Syntax: (setq {var form}*)\nVARs are not evaluated and must be symbols.  Assigns the value of the first\nFORM to the first VAR, then assigns the value of the second FORM to the second\nVAR, and so on.  Returns the last value assigned."
STRING
"\nArgs: (sym)\nReturns print-name of SYM if SYM is a symbol, or SYM if SYM is a string."
STRINGP
"Args: (x)\nReturns T if X is a string; NIL otherwise."
SYMBOLP
"Args: (x)\nReturns T if X is a symbol; NIL otherwise."
TERPRI
"Args: (&optional (stream *standard-output*))\nOutputs a newline character."
UNLESS
"Syntax: (unless test {form}*)\nIf TEST evaluates to NIL evaluates FORMs as a PROGN.  If not, returns NIL."
KIND-OF-P
"Args: (x y)
Returns T is X and Y are objects and X inherits from Y, NIL otherwise."
SLOT-VALUE
"Args: (slot &optional value)
Must be used in a method. Returns the value of current objects slot named SLOT.
If Value is supplied SLOT is set to VALUE. Can be used in setf."
MAKE-OBJECT
"Args: (&rest parents)
Returns a new object with parents PARENTS. If PARENTS is NIL (list *OBJECT*)
is used."
SEND
"Args: (object selector &rest args)
Applies first method for SELECTOR found in OBJECT's precedence list to
OBJECT and ARGS."
SEND-SUPER
"Args: (selector &rest args)
Apply inherited method. Must be used within a method. Specifically, Applies 
first method for SELECTOR found in the cdr of the precedence list of the owner
of the current method to the current object and args."
CALL-METHOD
"Args (object selector &rest args)
Funcalls method for SELECTOR found in OBJECT to SELF. Can only be used in a method."
CALL-NEXT-METHOD
"Args (&rest args)
Funcalls next method for current selector and precedence list. Can only be used in a method."
DEFMETH
"Syntax: (defmeth object name lambda-list [doc] {form}*)
OBJECT must evaluate to an existing object. Installs a method for NAME in
the value of OBJECT and installs DOC in OBJECTS's documentation."
DEFPROTO
"Syntax (defproto name &optional ivars cvars (parent *object*) doc)
Makes a new object prototype with instance variables IVARS, 'class'
variables CVARS and parents PARENT. PARENT can be a single object or
a list of objects. IVARS and CVARS must be lists."
