given
[1] A (required)
==> a 2d hermitian matrix
[2] result (keyword; new vector of appropriate size) <== a vector filled linearly with elements of A
converts 2d hermitian array into linearized form and returns
[1] result, a vector with 2d hermitian array stored in linearized form

Package: sapa.
Source: matrix.lisp.

Function: 2d-matrix-move! (from-this to-this) ¶

given
[1] from-this (required)
==> a 2d matrix
[2] to-this (required)
<== another 2d matrix
transfer contents of from-this to corresponding locations in to-this, and
returns
[1] to-this

Package: sapa.
Source: matrix.lisp.

Function: a*x (a x) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
returns
[1] a vector of numbers obtained by multiplying each element of x by a
—-
Note: corresponds to SSCAL in LINPACK’s bla.

Package: sapa.
Source: utilities.lisp.

Function: a*x! (a x &key result) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
[2] result (keyword; x)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by multiplying each element of x by a
—-
Note: corresponds to SSCAL in LINPACK’s bla.

Package: sapa.
Source: utilities.lisp.

Function: a*x+b (a x b) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
[3] b (required)
==> a number
returns
[1] a vector of numbers obtained by multiplying each element of x by a and adding b

Package: sapa.
Source: utilities.lisp.

Function: a*x+b! (a x b &key result) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
[3] b (required)
==> a number
[4] result (keyword; x)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by multiplying each element of x by a and adding b

Package: sapa.
Source: utilities.lisp.

Function: a*x+y (a x y) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
[3] y (required)
==> a sequence of numbers
returns
[1] a vector of numbers obtained by multiplying each element of x by a and adding the corresponding element of y
—-
Note: corresponds to SAXPY in LINPACK’s bla.

Package: sapa.
Source: utilities.lisp.

Function: a*x+y! (a x y &key result) ¶

given
[1] a (required)
==> a number
[2] x (required)
==> a sequence of numbers
[3] y (required)
==> a sequence of numbers
[4] result (keyword; y)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by multiplying each element of x by a and adding the corresponding element of y
—-
Note: corresponds to SAXPY in LINPACK’s bla.

Package: sapa.
Source: utilities.lisp.

Function: acvs (time-series &key start end center-data-p acs-p result) ¶

given
[1] time-series (required)
==> a vector containing the time series
[2] start (keyword; 0)
==> start index of time-series to be used
[3] end (keyword; length of time-series)
==> 1 + end index of time-series to be used
[4] center-data-p (keyword; t)
==> if t, subtract sample mean of time series
prior to computing the acvs;
if nil, do not subtract the sample mean
[5] acs-p (keyword; nil)
==> return autocorrelation sequence
rather than autocovariance sequence
[6] result (keyword; vector of length n)
<== vector to hold acvs (or acs)
calculates autocovariance (or autocorrelation) sequence using fft’s and returns
[1] result, a vector with the sample acvs (or acs)
[2] sample variance of time series (with mean treated
as specified by center-data-p keyword)
—
Note: see Equations (191a) and (190b) of the SAPA book

Package: sapa.
Source: acvs.lisp.

Function: acvs-for-time-series-simulated-from-sdf (n-series sdf &key sampling-time n-total result) ¶

given
[1] n-series (required)
==> length of time series simulated using simulate-time-series-from-sdf
(must be a power of 2)
[2] sdf (required)
==> spectral density function (sdf) defined for
0 <= f <= 1/(2.0 sampling-time) – the
sdf is assumed to be two-sided and symmetric about f = 0
[3] sampling-time (keyword; 1.0)
==> the assumed sampling time (delta t)
[4] n-total (keyword; 4 * next power of 2 for n-series) ==> a power of 2 controlling degree of accuracy
of the approximation (the larger, the better – see Percival, 1992, for details)
[5] result (keyword; vector of length n-series)
<== a vector to contain simulated time series returns
[1] a vector with the theoretical acvs from lag 0
to n-series - 1 for a time series generated via a call to simulate-time-series-from-sdf with n-series, sdf, sampling-time and n-total set to the same values

Package: sapa.
Source: random.lisp.

Function: add-sequences (&rest seqs) ¶

given
[1] a arbitrary number of sequences of numbers, all of the same size
returns
[1] a new sequence formed by adding the sequences together on an element by element basis

Package: sapa.
Source: utilities.lisp.

Function: ar-coeffs->acvs (ar-coeffs variance max-lag &key process-variance-p list-of-lower-order-phi list-of-lower-order-pev result) ¶

given
[1] AR-coeffs (required)
==> vector of length p with real or
complex-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[2] variance (required)
==> process variance (if process-variance-p is true)
or innovations variance (if nil)
[3] max-lag (required)
==> acvs to be computed out to this lag
[4] process-variance-p (keyword; t)
==> if true, required variance parameter
is taken to be process variance;
otherwise, it is taken to be the innovations
variance (both variance and process-variance-p
are ignored if the next two keyword parameters
are supplied)
[5] list-of-lower-order-phi (keyword; nil)
==> if supplied, bypasses call to step-down-Levinson-Durbin-recursions, in which case list-of-lower-order-pev must be supplied also
[6] list-of-lower-order-pev (keyword; nil)
==> if supplied, bypasses call to step-down-Levinson-Durbin-recursions [7] result (keyword; vector of size max-lag + 1)
<== vector to hold acvs for lags 0, 1, ..., max-lag
returns
[1] result, i.e., the acvs
—
Note: see Section 9.4 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: ar-coeffs->prewhitening-filter (ar-coeffs &key result) ¶

given
[1] AR-coeffs (required)
==> a sequence of AR coefficients
phi_{1,p}, ..., phi_{p,p}
[2] result (keyword; vector of size (1+ (length AR-coeffs))) <== sequence to hold coefficients for prewhitening filter 1, -phi_{1,p}, ..., -phi_{p,p}
returns
[1] result, the prewhitening filter
—
Note: this filter can be used to compute
forward prediction errors; to obtain
the filter needed to compute
backward prediction errors,
reverse the elements in result; i.e.,
evaluate (reverse result)

Package: sapa.
Source: parametric.lisp.

Function: ar-coeffs->reflection-coeffs (ar-coeffs &key list-of-lower-order-phi result) ¶

given
[1] AR-coeffs (required)
==> vector of length p with real or
complex-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[2] list-of-lower-order-phi (keyword; calls step-down-Levinson-Durbin-recursions) ==> must contain the list that is returned by
the function step-down-Levinson-Durbin-recursions;
this keyword parameter is useful if the result
of calling that function is already available
[3] results (keyword; vector of length p)
<== vector of size p into which
the reflection coefficients phi_{j,j}
of orders j = 1, 2, ..., p are placed
returns
[1] results, i.e., the reflection coefficients
—
Note: see Section 9.4 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: ar-coeffs->sdf (ar-coeffs innovations-variance &key n-nonzero-freqs sampling-time return-est-for-0-freq-p sdf-transformation result-sdf return-frequencies-p freq-transformation result-freq) ¶

given
[1] AR-coeffs (required)
==> vector with real-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[2] innovations-variance (required)
==> innovations variance of the process
[3] N-nonzero-freqs (keyword; 256)
==> the number of nonzero frequencies at which the AR sdf
is to be computed (need NOT be a power of 2);
the first nonzero frequency (and also spacing
between frequencies) is given by
1/(2 * N-nonzero-freqs * sampling time)
= Nyquist frequency/N-nonzero-freqs;
the last nonzero frequency is the Nyquist frequency
[4] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[5] return-est-for-0-freq-p (keyword; t)
==> if t, sdf is computed at zero frequency;
otherwise, it is not computed.
[6] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[7] result-sdf (keyword; vector of correct length)
<== vector of length N-nonzero-freqs (if return-est-for-0-freq-p is nil) or N-nonzero-freqs +1 (if return-est-for-0-freq-p is t)
into which the properly transformed sdf is placed
[8] return-frequencies-p (keyword; nil)
==> if t, the frequencies associated with the transfer function
are computed and returned in result-freq
[9] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[10] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of length N-nonzero-freqs (if return-est-for-0-freq-p is nil) or N-nonzero-freqs +1 (if return-est-for-0-freq-p is t)
into which the frequencies associated with the values
in result-sdf are placed
returns
[1] result-sdf, a vector holding
the properly transformed sdf
[2] nil (if return-frequencies-p is nil) or
result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-sdf
[3] the length of the vector result-sdf
—
Note: see Equation (392b) of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: ar-coeffs->sdf-at-single-freq (ar-coeffs innovations-variance freq &key sampling-time sdf-transformation) ¶

Package: sapa.
Source: parametric.lisp.

Function: ar-coeffs->variance (ar-coeffs innovations-variance) ¶

given
[1] AR-coeffs (required)
==> a sequence of AR coefficients phi_{1,p}, ..., phi_{p,p}
[2] innovations-variance (required)
==> innovations variance of the process returns
[1] variance of the process

Package: sapa.
Source: parametric.lisp.

Function: bandwidth&confidence-intervals-for-sdf-db (sdf-db freq sample-size &key confidence-level lag-window-function max-lag sampling-time c_h) ¶

given
[1] sdf-dB (required)
==> an sdf estimate (in decibels) for a single frequency
[2] freq (required)
==> the frequency associated with sdf-dB
[3] sampling-size (required)
==> the sample size of the time series
from which sdf-dB was computed
[4] confidence-level (keyword; 0.95)
==> the level of the confidence interval
(e.g., 0.95 yields a 95% confidence interval)
[5] lag-window-function (keyword; nil)
==> the lag window function used to create
sdf-dB (nil means a lag window function was NOT used) [6] max-lag (keyword; sample-size - 1)
==> the maximum lag used in conjunction with lag-window-function to create sdf-dB (not used in lag-window-function is nil) [7] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[8] C_h (keyword; 1.0)
==> the variance inflation factor due to tapering
(see Table 248 of the SAPA book); the default value
of 1.0 is appropriate for a rectangular data taper returns
[1] left-hand size of interval describing the bandwidth of
the spectral estimate (interval is centered on freq)
[2] right-hand size of bandwidth interval
[3] lower limit (in decibels) of confidence interval for
true sdf based upon sdf-dB
[4] upper limit (in decibels) of confidence interval
—
Note: see Sections 6.7 and 6.10 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: bartlett-bandwidth->m (b_w &key sampling-time) ¶

given desired smoothing window bandwidth B_W and sampling time, returns
[1] window parameter m required to approximately achieve B_W using the Bartlett lag window
[2] actual B_W achieved
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: bartlett-lag-window (tau m) ¶

given the lag tau and window parameter m, returns the value of the Bartlett lag window —
Note: see Equation (260) of the SAPA book or Priestley, page 439, Equation (6.2.65)

Package: sapa.
Source: nonparametric.lisp.

Function: bartlett-m->bandwidth (m &key sampling-time) ¶

given window parameter m and sampling time,
returns bandwidth B_W for the Bartlett smoothing window —
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: bartlett-n-m->degrees-of-freedom (n m &key c_h) ¶

given sample size N, window parameter m and variance inflation factor C_h, returns equivalent degrees of freedom nu for Bartlett lag window
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: biased-acvs->unbiased-acvs (biased-acvs) ¶

given a biased estimate of the acvs, returns the corresponding unbiased estimate

Package: sapa.
Source: acvs.lisp.

Function: binary-search (value ordered-seq &key lower-test upper-test) ¶

given
[1] value (required)
==> a real-valued number
[2] ordered-seq (required)
==> an ordered sequence of real-valued numbers
[3] lower-test (keyword; #’<=)
==> a predicate of two arguments
that defines the lower test
[4] upper-test (keyword; #’<=)
==> a predicate of two arguments
that defines the upper test
returns
[1] if lower-test and upper-test are set
to their default values, this function
returns an index i such that v[i] <= value <= v[i+1],
where 0 <= i <= n-2 (if there is no such i, nil is returned); if nondefault values are supplied for lower-test and upper-test, then the condition ‘v[i] <= value <= v[i+1]’
gets modified in an obvious way
—
Note: value can be an arbitrary object, and ordered-seq
can be a list of arbitrary objects if the binary predicates lower-test and upper-test are appropriate set

Package: sapa.
Source: utilities.lisp.

Function: bisection-with-newton-raphson (f f-prime x-left x-right &key accuracy maximum-number-of-iterations) ¶

given
[1] f (required)
==> a function with a single argument
[2] f-prime (required)
==> another function with a single argument, this one being the first derivative of f [3] x-left (required)
==> left-hand bracket for the desired root; i.e., left-hand bracket <= desired root [4] x-right (required)
==> right-hand bracket for the desired root; i.e., desired root <= right-hand bracket [5] accuracy (keyword; (* 10.0 single-float-epsilon)) ==> desired relative accuracy for computed rood [6] maximum-number-of-iterations (keyword; 100) ==> maximum number of iterations
returns
[1] a root of f in [x-left, x-right];
i.e., a value x in that interval
such that f(x) = 0
[2] the number of iterations required
—
Note: this function is based loosely on rtsafe, Section 9.4, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: box-plot (a-seq &key seq-sorted-p get-bottom-line get-bottom-of-box get-line-through-box get-top-of-box get-top-line) ¶

given
[1] a-seq (required)
==> a sequence of real-valued numbers
[2] seq-sorted-p (keyword; nil)
==> if t, a-seq is already sorted;
if nil, a copy of a-seq is sorted
for use by the function
[3] get-bottom-line (keyword; computes lower adjacent value) ==> a function for calculating
the line below the box (from sorted data)
[4] get-bottom-of-box (keyword; computes lower quartile) ==> a function for calculating
bottom of the box
[5] get-line-through-box (keyword; computes median)
==> a function for calculating
the line through the middle of the box
[6] get-top-of-box (keyword; computes upper quartile) ==> a function for calculating
top of the box
[7] get-top-line (keyword; computes upper adjacent value) ==> a function for calculating
the line above the box
returns
[1] bottom line below box
[2] bottom line of box
[3] line through middle of box
[4] top line of box
[5] top line above box
[6] a vector containing outside values
(note: this vector can be of length 0)
—
Note: the values that this function returns can
be used to contruct a box plot as defined in
Section 2.5 of “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner, Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: burg-algorithm (time-series p &key start end center-data ar-coeffs approximate-mses reflection-coeffs forward-prediction-errors backward-prediction-errors exact-mses) ¶

given
[1] time-series (required)
==> a vector containing a real-valued or
complex-valued time series x_t
[2] p (required)
==> autoregressive model order;
p should be an integer > 0 and < end - start
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, the effect of this function is to return
a copy of the relevant portion of time-series
[6] AR-coeffs (keyword; a vector of length p)
<== estimates of AR coefficients phi_{1,p}, ..., phi_{p,p}
[7] approximate-MSEs (keyword; a vector of length p+1)
<== estimates of innovations variance (mean square errors)
for models of order 0, 1, ..., p (the innovations variance
for the zeroth order model is the sample variance)
[8] reflection-coeffs (keyword; a vector of length p)
<== estimates of reflection coefficients phi_{1,1}, ..., phi_{p,p} [9] forward-prediction-errors (keyword; a vector of length end - start - p) <== computed forward prediction errors
[10] backward-prediction-errors (keyword; a vector of length end - start - p) <== computed backward prediction errors
[11] exact-MSEs (keyword; a vector of length p+1)
<== another set of estimates of innovations variance
for models of order 0, 1, ..., p; these estimates
are based on Equation (419a) of the SAPA book
uses Burg’s algorithm to estimate the phi’s in the model
x_t = phi_{1,p} x_{t-1} + ... + phi_{p,p} x_{t-p} + e_t
and returns
[1] AR-coeffs, a vector containing phi_{1,p}, ..., phi_{p,p}
[2] estimate of the innovations variance, i.e.,
the variance of the e_t’s; this number is also given in
(elt approximate-MSEs p)
[3] approximate-MSEs
[4] reflection-coeffs
[5] forward-prediction-errors
[6] backward-prediction-errors
[7] exact-MSEs
—
Note: see Section 9.5 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: careful-convert-to-db (num &optional zero-mapping) ¶

given
[1] num (required)
==> a number
[1] zero-mapping (required) ==> a number
returns
[1] 10 log_10(num) if num > 0 or zero-mapping if num <= 0

Package: sapa.
Source: utilities.lisp.

Function: center&prewhiten&taper-time-series (time-series &key center-data start end prewhitening-filter recenter-after-prewhitening-p data-taper data-taper-parameters recenter-after-tapering-p restore-power-option-p result) ¶

given
[1] time-series (required)
==> a sequence of time series values
[2] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series; if nil, time-series is not centered
[3] start (keyword; 0)
==> start index of sequence to be used
[4] end (keyword; length of time-series)
==> 1 + end index of sequence to be used
[5] prewhitening-filter (keyword; nil)
==> vector with coeffients of prewhitening filter
or nil (if no prewhitening is to be done)
[6] recenter-after-prewhitening-p (keyword; t)
==> if t, prewhitened series is centered using sample mean (not used if prewhitening-filter is nil)
[7] data-taper (keyword; nil)
==> nil or a tapering function
[8] data-taper-parameters (keyword)
==> parameters for tapering function (not used
if data-taper is nil)
[9] recenter-after-tapering-p (keyword; t)
==> if t and data-taper is a function,
centers tapered series by subtracting
off its sample mean
[10] restore-power-option-p (keyword; t)
==> if t and data-taper is a function,
normalizes tapered series to have same
sum of squares as before tapering
[11] result (keyword; vector of size (- end start))
<== sequence to hold centered, prewhitened
and tapered time series
returns
[1] result, the sequence containing the centered, prewhitened and tapered time series (time-series are unaltered unless it is bound to result)
[2] the number used to center the time series
(this is nil if center-data is nil)
[3] C_h, the variance inflation factor due to the data taper —
Note: see also center&taper-time-series in tapers.lisp

Package: sapa.
Source: filtering.lisp.

Function: center&taper-time-series (time-series &key center-data start end data-taper data-taper-parameters recenter-after-tapering-p restore-power-option-p result) ¶

given
[1] time-series (required)
==> a sequence of time series values
[2] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series; if nil, the effect of this function is to return a copy of the relevant portion of time-series [3] start (keyword; 0)
==> start index of sequence to be used
[4] end (keyword; length of time-series)
==> 1 + end index of sequence to be used
[5] data-taper (keyword; nil)
==> nil or a tapering function
[6] data-taper-parameters (keyword)
==> parameters for tapering function (not used
if data-taper is nil)
[7] recenter-after-tapering-p (keyword; t)
==> if t and data-taper is a function,
centers tapered series by subtracting
off its sample mean
[8] restore-power-option-p (keyword; t)
==> if t and data-taper is a function,
normalizes tapered series to have same
sum of squares as before tapering
[9] result (keyword; vector of size (- end start))
<== sequence to hold centered time series
returns
[1] result, the sequence containing the centered and/or tapered time series (the contents of time-series
are unaltered unless it is also bound to result)
[2] the number used to center the time series
(this is nil if center-data is nil)
[3] C_h, the variance inflation factor due to the data taper —
Note: see also center&prewhiten&taper-time-series
in filtering.lisp

Package: sapa.
Source: tapers.lisp.

Function: cepstrum->i_m (cepstrum &key sampling-time n-prime lag-window-function lambda-factor result) ¶

given
[1] cepstrum (required)
==> a vector of length N_U+1 with values of the cepstrum from lag 0 to N_U
[2] sampling-time (keyword; 1.0)
==> the sample time (i.e., delta t)
[3] N-prime (keyword; 2 * N_U)
==> effective sample size, as discussed in Section 6.15 of the SAPA book (default value ok if N-prime is even, but must be replaced if N-prime is odd)
[4] lag-window-function (keyword; #’parzen-lag-window)
==> lag window function of 2 parameters,
tau (the lag) and m (the window parameter)
[5] lambda-factor (keyword; 1.0)
==> lambda, as discussed in Section 6.15 of the SAPA book [6] result (keyword; vector of same length as cepstrum) <== vector to hold I_m
returns
[1] the value m at which I_m is minimized
[2] result, i.e., I_m for m = 0 to N_U
[3] the minimum value of I_m for m = 0 to N_U
—
Note: see Equation (283b) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: check-orthonormality (list-of-vectors) ¶

given a list of vectors, computes and prints their sum of squares and pairwise dot products, and returns the maximum absolute deviation from 0
of the pairwise dot products

Package: sapa.
Source: multitaper.lisp.

Function: cholesky! (a b &key eps) ¶

given
[1] A (required)
==> vector of length N*(N+1)/2 representing
a two dimensional N by N positive definite matrix
with elements stored columnwise; i.e, elements with indices 0 1 2 3 4 5 ...
correspond to matrix positions
1,1 1,2 2,2 1,3 2,3 3,3 ...
[2] b (required)
<=> right-hand vector on input;
solution X on output
[3] eps (keyword; single-float-epsilon)
number used to test for a computationally singular matrix solves A X = b using the Cholesky decomposition method, and returns
[1] X, the solution vector (stored in b)

Package: sapa.
Source: matrix.lisp.

Function: circular-shift-sequence (a-seq &key result) ¶

given
[1] a-seq (required)
==> a sequence
[2] result (keyword; vector of same length as a-seq) <== a sequence
returns
[1] a ‘circularly’ left-shifted sequence; i.e., maps x(0), x(1), x(2), ..., x(n-2), x(n-1) to x(n-1), x(0), x(1), ..., x(n-3), x(n-2) —-
Note: result can be the same sequence as result

Package: sapa.
Source: utilities.lisp.

Function: compare-seqs (one-seq another-seq) ¶

given
[1] one-seq (required)
==> any sequence
[2] another-seq (required)
==> any sequence (must be same length as one-seq) returns
[1] maximum absolute difference between corresponding elements of the two sequences
[2] average absolute difference
—
Note: useful for comparing results that in theory should be identical

Package: sapa.
Source: utilities.lisp.

Function: compose-symmetric-filters (&rest filters) ¶

given any number of symmetric filters (each of odd length and each represented by a vector of coefficients), returns the composite filter
that will produce an output identical to that obtained
by cascading the individual filters

Package: sapa.
Source: filtering.lisp.

Function: convert-from-db (num) ¶

given
[1] num (required) ==> a number returns
[1] 10^(x/10)

Package: sapa.
Source: utilities.lisp.

Function: convert-to-db (num) ¶

given
[1] num (required)
==> a number
returns
[1] 10 log_10(num)
—
Note: num is intended to be a positive number, but this is not checked

Package: sapa.
Source: utilities.lisp.

Function: copy-vector (from-vector to-vector &key start end) ¶

given
[1] from-vector (required)
==> a vector (actually, works with any sequence) [2] to-vector (required)
==> a vector (actually, works with any sequence) [3] start (keyword; 0)
==> start index of from-vector to be transferred [4] end (keyword; length of from-vector)
==> 1 + end index of from-vector to be transferred returns
[1] to-vector, with elements start to end - 1 from-vector copied into corresponding
elements 0 to end - start - 1 of to-vector
—
Note: if to-vector is being created on the spot, might consider using CL’s copy-seq instead.

Package: sapa.
Source: utilities.lisp.

Function: cosine-data-taper! (a-time-series &key taper-parameter normalization result) ¶

given
[1] a-time-series (required)
<=> a vector containing a time series;
this vector is modified UNLESS keyword result
is bound to a different vector
[2] taper-parameter (keyword; 1.0, i.e., Hanning data taper) ==> a number >= 0.0 and <= 1.0 that specifies the degree of tapering (parameter p of Equation (209)).
[3] normalization (keyword; :unity)
==> if :unity, taper normalized such that
its sum of squares is equal to unity (Equation (208a)); if :N, taper normalized such that
its sum of squares is equal to the number of points in the time series
[4] result (keyword; a-time-series)
<=> a vector to contain time series multiplied
by cosine data taper
returns
[1] a vector containing the tapered time series
[2] C_h, the variance inflation factor
computed using Equation (251b) in the SAPA book

Package: sapa.
Source: tapers.lisp.

Function: create-ci-for-amt-sdf-estimate (sdf-db dofs &key confidence-level) ¶

given
[1] sdf-dB (required)
==> vector containing an adaptive multitaper spectral estimate expressed in decibels
[2] dofs (required)
==> vector containing the degrees of freedom associated with the values in sdf-dB
[3] confidence-level (keyword; 0.95)
==> the level of the confidence intervals to be created returns
[1] a vector containing the upper confidence interval [2] a vector containing the lower confidence interval —
Note: see Section 7.4 of the SAPA book

Package: sapa.
Source: multitaper.lisp.

Function: create-dpss-low-pass-filter (filter-length delta w &key nyquist-frequency result) ¶

given
[1] filter-length (required)
==> an odd positive integer = 2L +1
[2] delta (required)
==> “W” parameter for dpss in user
units (see page 182 of the SAPA book)
[2] W (required)
==> a cutoff frequency greater than 0
and less than the Nyquist frequency
[3] Nyquist-frequency (keyword; 0.5)
==> the Nyquist frequency
[4] result (keyword; vector of length filter-length)
<== vector of length filter-length
into which filter coefficients
are placed (returned by the function)
uses a dpss as convergence factors in least squares approximation to a low-pass filter and
returns
[1] a symmetric low-pass filter of length 2L+1
and a gain of unity at zero frequency;
i.e., result(0) = result(2L)
result(1) = result(2L-1)
etc., and
(sum result) = 1.0
—
Note: see Section 5.9 of the SAPA book;
(aref result 0) corresponds to element -L of the filter; (aref result L) corresponds to element 0 of the filter; (aref result (* 2 L)) corresponds to element L of the filter

Package: sapa.
Source: filtering.lisp.

Function: create-least-squares-low-pass-filter (filter-length w &key convergence-factors nyquist-frequency result) ¶

given
[1] filter-length (required)
==> an odd positive integer = 2L +1
[2] W (required)
==> a cutoff frequency greater than 0
and less than the Nyquist frequency
[3] convergence-factors (keyword; nil)
==> a one-argument function that maps
an integer to a convergence factor;
nil is also acceptable, in which case
no convergence factors are used
[4] Nyquist-frequency (keyword; 0.5)
==> the Nyquist frequency
[5] result (keyword; vector of length filter-length)
<== vector of length filter-length
into which filter coefficients
are placed (returned by the function)
uses a least squares approximation to a low-pass filter and returns
[1] a symmetric low-pass filter of length 2L+1
and a gain of unity at zero frequency;
i.e., result(0) = result(2L)
result(1) = result(2L-1)
etc., and
(sum result) = 1.0
—
Note: see Section 5.8 of the SAPA book;
(aref result 0) corresponds to element -L of the filter; (aref result L) corresponds to element 0 of the filter; (aref result (* 2 L)) corresponds to element L of the filter

Package: sapa.
Source: filtering.lisp.

Function: cumulative-periodogram (time-series &key sampling-time center-data start end cumulative-periodogram-test-p significance-level scratch-dft return-frequencies-p result-freq result) ¶

given
[1] time-series (required)
==> a vector containing time series values
[2] sampling-time (keyword; 1.0)
==> the sample time (i.e., delta t)
[3] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series; if nil, time-series is not centered
[4] start (keyword; 0)
==> start index of vector to be used
[5] end (keyword; length of time-series)
==> 1 + end index of vector to be used
[6] cumulative-periodogram-test-p (keyword; t)
==> if t, returns values associated with
Kolmogorov test statistic
[7] significance-level (keyword; 0.95)
==> level of significance at which Kolmogorov test
is performed
[8] scratch-dft (keyword; vector of size (- end start))
==> scratch vector used for in-place dft calculations
[9] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the cumulative periodogram are computed and returned in result-freq [10] result-freq (keyword; nil or vector of correct length) <== not used if return-frequencies-p nil; otherwise, vector of correct length into which the frequencies associated with the values in result are placed
[11] result (keyword; vector of correct length)
<== vector to hold normalized cumulative periodogram returns
[1] vector with normalized cumulative periodogram
[2] vector with associated frequencies
and – if cumulative-periodogram-test-p is true –
[3] Kolmogorov test statistic
[4] index of maximum deviation
[5] frequency of maximum deviation
[6] quantile of Kolmogorov test statistic (under null hypothesis) [7] either :reject or :fail-to-reject, depending on whether or not we reject or fail to reject the null hypothesis [8] slope of upper and lower lines
[9] intercept of upper line
[10] intercept of lower line
—
Note: see Section 6.6 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: cumulative-sums (the-seq &key start end result) ¶

given
[1] the-seq (required)
==> a sequence of numbers
[2] start (keyword; 0)
==> start index of sequence to be used [3] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used returns
[1] sequence with cumulative sum
of elements in specified subsequence

Package: sapa.
Source: utilities.lisp.

Function: daniell-bandwidth->m (b_w &key sampling-time) ¶

given desired smoothing window bandwidth B_W and sampling time, returns
[1] window parameter m required to approximately achieve B_W using the Daneill lag window
[2] actual B_W achieved (in fact, this is always equal to B_W, but we return it anyway for consistency with other lag windows) —
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: daniell-lag-window (tau m) ¶

given the lag tau and window parameter m,
returns the value of the Daniell lag window
—
Note: see equation between Equations (264a) and (264b) of the SAPA book or Priestley, page 441, Equation (6.2.73)

Package: sapa.
Source: nonparametric.lisp.

Function: daniell-m->bandwidth (m &key sampling-time) ¶

given window parameter m and sampling time, returns bandwidth B_W for the Daniell smoothing window —
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: daniell-n-m->degrees-of-freedom (n m &key c_h) ¶

given sample size N, window parameter m and variance inflation factor C_h, returns equivalent degrees of freedom nu for Daniell lag window
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: dft! (x &key n sampling-time) ¶

given:
[1] x (required)
<=> a vector of real or complex-valued numbers [2] N (keyword; length of x)
==> number of points in dft
[3] sampling-time (keyword; 1.0)
returns:
[1] x, with contents replaced by
the discrete Fourier transform of x, namely, N-1
X(n) = sampling-time SUM x(t) exp(-i 2 pi n t/N) t=0
—
Note: see Equation (110a) of the SAPA book

Package: sapa.
Source: dft-and-fft.lisp.

Function: dft-chirp! (complex-vector &key n) ¶

given:
[1] complex-vector (required)
<=> a vector of real or complex-valued numbers [2] N (keyword; length of complex-vector)
==> number of points (must be a power of 2) computes the discrete Fourier transform of complex-vector using a chirp transform algorithm and
returns:
[1] complex-vector, with contents replaced by
the discrete Fourier transform of the input, namely, N-1
X(n) = SUM x(t) exp(-i 2 pi n t/N) t=0
—
Note: see Equation (110a) of the SAPA book
with the sampling time set to unity and
also Section 3.10 for a discussion on
the chirp transform algorithm

Package: sapa.
Source: dft-and-fft.lisp.

Function: difference (sequence-of-numbers &key start end lag result) ¶

given
[1] sequence-of-numbers (required)
==> a sequence of numbers
[2] start (keyword; 0)
==> start index
[3] end (keyword; length of sequence-of-numbers)
==> end index plus one
[4] lag (keyword; 1)
==> lag for differencing
[5] result (keyword; vector of length (- end start lag)) <== results
return
[1] a sequence of length (- end start lag)
with lag-th order difference of sequence
from index start to index end-1
—
Note: See Newton, 1988, page 31.

Package: sapa.
Source: utilities.lisp.

Function: digamma (x &key x-recursion x-small) ¶

given
[1] x (required)
==> a positive number
[2] x-recursion (keyword; 8.5)
==> for noninteger x,
if x-small < x < x-recursion,
recursive formula is used
[3] x-small (keyword; 1.0e-5)
==> if x <= x-small,
small x approximation used (default )
returns
[1] value of digamma (psi, derivative of log(gamma)) function at x —
Note: see Abramowitz and Stegun’s equation 6.3.2;
expansion 6.3.18 plus recurrence 6.3.5;
the small x formula is Equation (5) from
Algorithm AS 103 – Psi (Digamma) Function – by J. M. Bernardo in Applied Statistics, Vol. 25, No. 3, 1976, pp. 315–317;
note that better accuracy can be obtained by increasing x-recursion — 10.0 to 100.0 are probably useful values

Package: sapa.
Source: basic-math.lisp.

Function: direct-spectral-estimate (time-series &key center-data start end n-nonzero-freqs return-est-for-0-freq-p sampling-time scratch-dft data-taper data-taper-parameters recenter-after-tapering-p restore-power-option-p return-acvs-p result-acvs sdf-transformation result-sdf return-frequencies-p freq-transformation result-freq) ¶

given
[1] time-series (required)
==> a vector of time series values
[2] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, time-series is not centered
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of time-series)
==> 1 + end index of vector to be used
[5] N-nonzero-freqs (keyword; :half-next-power-of-2)
==> specifies at how many nonzero frequencies
direct spectral estimate is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [6] return-est-for-0-freq-p (keyword; nil)
==> if t, sdf is computed at zero frequency;
otherwise, it is not computed.
[7] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[8] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[9] data-taper (keyword; nil)
==> nil or a tapering function
[10] data-taper-parameters (keyword)
==> parameters for tapering function (not used
if data-taper is nil)
[11] recenter-after-tapering-p (keyword; t)
==> if t and data-taper is a function,
centers tapered series by subtracting
off its sample mean
[12] restore-power-option-p (keyword; t)
==> if t and data-taper is a function,
normalizes tapered series to have same
sum of squares as before tapering
[13] return-acvs-p (keyword; nil)
==> if t, computes acvs corresponding
to direct spectral estimate
[14] result-acvs (keyword; vector of correct length)
<== vector into which acvs values are placed
(not used if return-acvs-estimate-p is nil)
[15] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[16] result-sdf (keyword; vector of correct length)
<== vector into which direct spectral estimates are placed; it must be exactly of the length dictated
by N-nonzero-freqs and return-est-for-0-freq-p
[17] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral estimate are computed and returned in result-freq
[18] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[19] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of length dictated by
N-nonzero-freqs and return-est-for-0-freq-p
into which the frequencies associated with the values in result-sdf are placed
returns
[1] result-sdf, a vector holding
the properly transformed sdf
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-sdf
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-sdf
[4] C_h, the variance inflation factor due to the data taper [5] result-acvs (if return-acvs-p is t),
a vector holding the acvs corresponding
to the direct spectral estimate
– or –
nil (if return-acvs-p is nil)
—
Note: see Section 6.3 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: dot-product (x y) ¶

given
[1] x (required)
==> a sequence of numbers
[2] y (required)
==> a sequence of numbers returns
[1] the dot product of x and y
—-
Note: corresponds to SDOT in LINPACK’s bla

Package: sapa.
Source: utilities.lisp.

Function: dpss-data-taper! (a-time-series &key taper-parameter normalization result) ¶

given
[1] a-time-series (required)
<=> a vector containing a time series;
this vector is modified UNLESS keyword result
is bound to a different vector
[2] taper-parameter (keyword; 4.0)
==> a number > 0.0 that specifies NW,
the product of the sample size and
the half-width of the concentration interval
(see SAPA, page 211)
[3] normalization (keyword; :unity)
==> if :unity, taper normalized such that
its sum of squares is equal to unity (Equation (208a)); if :N, taper normalized such that
its sum of squares is equal to the number of points in the time series
[4] result (keyword; a-time-series)
<=> a vector to contain time series multiplied
by cosine data taper
returns
[1] a vector containing the tapered time series
[2] C_h, the variance inflation factor
computed using Equation (251b) in the SAPA book

Package: sapa.
Source: tapers.lisp.

Function: dpss-tapers-inverse-iteration (n number-of-tapers &key taper-parameter print-progress-p eps) ¶

Package: sapa.
Source: multitaper.lisp.

Function: dpss-tapers-thomson-approx (n number-of-tapers &key taper-parameter print-progress-p compute-true-eigenvalues-p abscissas weights) ¶

given
[1] N (required)
the sample size
[2] number-of-tapers (required)
number of orthonormal dpss data tapers
to be computed
[3] taper-parameter (keyword; 4.0)
NW, the duration-half-bandwidth product
(must be such that 0 < NW/N < 1/2)
[4] print-progress-p (keyword; nil)
if t, prints a dot after each eigenvalue
and eigenvector has been computed
[5] compute-true-eigenvalues-p (keyword; nil)
if t, returns eigenvalues for eigenproblem
of Equation (378) of the SAPA book;
if nil, returns nil
[6] abscissas (keyword; *abscissas-32-point*)
a vector of abscissas points used
in Gauss-Legendre quadrature
[7] weights (keyword; *abscissas-32-point*)
a vector of weights used
in Gauss-Legendre quadrature
returns
[1] a list of length number-of-tapers of N dimensional vectors with orthonormal dpss’s of orders 0, 1, ..., number-of-tapers - 1; [2] a vector of length number-of-tapers with
eigenvalues if compute-true-eigenvalues-p is t;
nil if if compute-true-eigenvalues-p is nil
—
Note: computes the dpss tapers using Thomson’s numerical
integration scheme (see Section 8.2 of the SAPA book)

Package: sapa.
Source: multitaper.lisp.

Function: dpss-tapers-tri-diag (n number-of-tapers &key taper-parameter print-progress-p compute-true-eigenvalues-p) ¶

given
[1] N (required)
the sample size
[2] number-of-tapers (required)
number of orthonormal dpss data tapers
to be computed
[3] taper-parameter (keyword; 4.0)
NW, the duration-half-bandwidth product
(must be such that 0 < NW/N < 1/2)
[4] print-progress-p (keyword; nil)
if t, prints a dot after each eigenvalue
and eigenvector has been computed
[5] compute-true-eigenvalues-p (keyword; nil)
if t, returns eigenvalues for eigenproblem
of Equation (378) of the SAPA book;
if nil, returns eigenvalues for tridiagonal
formulation
returns
[1] a list of length number-of-tapers of N dimensional vectors with orthonormal dpss’s of orders 0, 1, ..., number-of-tapers - 1; [2] a vector of length number-of-tapers with
eigenvalues as specified by compute-true-eigenvalues-p
—
Note: computes the dpss tapers using the tridiagonal
formulation (see Section 8.3 of the SAPA book)

Package: sapa.
Source: multitaper.lisp.

Function: durbin-watson-test-statistic (residuals) ¶

given a set of residuals in a seqeunce, returns the Durbin-Watson test statistic

Package: sapa.
Source: basic-statistics.lisp.

Function: eigenspectra->adaptive-multitaper-spectral-estimate (list-of-eigenspectra eigenvalues variance-of-time-series &key sampling-time n-eigenspectra maximum-number-of-iterations result-dof sdf-transformation result-sdf) ¶

given
[1] list-of-eigenspectra (required)
==> list of eigenspectra (such as optionally returned
by multitaper-spectral-estimate); each eigenspectrum
is assumed to be untransformed (e.g., not expressed
in dB)
[2] eigenvalues (required)
==> vector of eigenvalues corresponding to the dpss’s
used to create the eigenspectra (the length of eigenvalues should be at least as large as the length specified
by N-eigenspectra)
[3] variance-of-time-series (required)
==> variance of time series
from which eigenspectra were computed
[4] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[5] N-eigenspectra (keyword; length of list-of-eigenspectra)
==> number of eigenspectra to be used (must be less than
or equal to the length of list-of-eigenspectra)
[6] maximum-number-of-iterations (keyword; 100)
==> maximum number of iterations
[7] result-dof (keyword; vector of correct length)
<== vector into which degrees of freedom for each value
in the adaptive multitaper spectral estimate is placed;
it must be exactly the same length as each of the vectors
in list-of-eigenspectra
[8] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[9] result-sdf (keyword; vector of correct length)
<== vector into which adaptive multitaper spectral estimate is placed; it must be exactly the same length as each of the vectors
in list-of-eigenspectra
returns
[1] result-sdf, a vector holding
the properly transformed adaptive multitaper spectral estimate
[2] result-dof, a vector holding corresponding degrees of freedom
[3] the maximum number of iterations required to reach convergence
for all of the values in result-sdf
—
Note: see Section 7.4 of the SAPA book

Package: sapa.
Source: multitaper.lisp.

Function: eigenspectra->multitaper-spectral-estimate (list-of-eigenspectra &key n-eigenspectra sdf-transformation result-sdf) ¶

given
[1] list-of-eigenspectra (required)
==> list of eigenspectra (such as optionally returned
by multitaper-spectral-estimate); each eigenspectrum is assumed to be untransformed (e.g., not expressed in dB) and represented by a vector
[2] N-eigenspectra (keyword; length of list-of-eigenspectra) ==> number of eigenspectra to be used (must be less than or equal to the length of list-of-eigenspectra)
[3] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[4] result-sdf (keyword; vector of correct length)
<== vector into which multitaper spectral estimate is placed; it must be exactly the same length as each of the vectors in list-of-eigenspectra
returns
[1] result-sdf, a vector holding
the properly transformed multitaper spectral estimate
—
Note: see Section 7.1 of the SAPA book

Package: sapa.
Source: multitaper.lisp.

Function: equivalent-degrees-of-freedom (lag-window-function max-lag &key sampling-time sample-size c_h) ¶

given a lag window function, a maximum lag, the sampling time, the sample size and the variance inflation factor C_h, returns the corresponding equivalent degrees of freedom —
Note: see Equation (255a) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: euclidean-norm (x) ¶

given
[1] x (required)
==> a sequence of numbers returns
[1] Euclidean norm of x
—-
Note: corresponds to LINPACK’s SNRM2, but this is POOR implementation!

Package: sapa.
Source: utilities.lisp.

Function: evaluate-polynomial (polynomial z &key degree-of-polynomial number-of-derivatives complex-values bounds-to-be-computed bounds) ¶

given
[1] polynomial (required)
==> sequence of length n+1 with real or
complex-valued numbers giving the n+1
coefficients of a polynomial of nth order;
(elt polynomial i) = coefficient of z^(n-i)
[2] z (required)
==> complex point at which the polynomial
to be evaluated
[3] degree-of-polynomial (keyword; (1- (length polynomial)))
==> degree of polynomial
[4] number-of-derivatives (keyword; 0)
==> number of derivatives to be evaluated
[5] complex-values (keyword; array of length (1+ number-of-derivatives)) <== sequence with values of polynomial
and derivatives
[6] bounds-to-be-computed (keyword; nil)
==> if t, error bounds are computed
for values in complex-values
[7] bounds (keyword; array of length (1+ number-of-derivatives))
<== sequence with error bounds
returns
[1] the sequence complex-values containing the value
of the polynomial and its derivatives
[2] bounds, a sequence containing optional error bounds
—
Note: this is a Lisp version of cmlib routine cpevl;
d1 was specified in cpevl as (expt 2 (- 1 (i1mach 11))),
where (i1mach 11) ==> THE NUMBER OF BASE-2 DIGITS (SINGLE PRECISION).
I have taken this to be equivalent to machine epsilon.
If this is in fact NOT the case, then the optional error bounds
might not be computed correctly.

Package: sapa.
Source: basic-math.lisp.

Function: exponential-smoothing (time-series alpha &key initial-prediction return-smoothed-values-p n-predictions result-smoothed result-predictions) ¶

given
[1] time-series (required)
==> a sequence of numbers
[2] alpha (required)
==> parameter controlling the degree of exponential smoothing (usually 0 < alpha < 1)
[3] initial-prediction (keyword; first element of time-series)
==> to get the smoother going, we need a “prediction” for
the first element in the sequence time-series – two
common hacks are the first element itself (the default)
or 0 (if the time series has a zero sample mean)
[4] return-smoothed-values-p (keyword; t)
==> if t, returns smoothed (i.e., filtered) time series
[5] n-predictions (keyword; 0)
==> number of predictions desired
[6] result-smoothed (keyword; vector of length of time-series or nil) <== a sequence to hold smoothed (filtered) time series – used only if return-smoothed-values-p is true
[7] result-predictions (keyword; vector of length n-predictions or nil) <== a sequence to hold predicted values of the time series – used only if n-predictions is positive
returns
[1] sum-of-squares of prediction errors
[2] either one step ahead prediction (if n-predictions is 0)
or vector of length n-predictions if n-predictions > 0)
[3] vector with smoothed values
(nil if return-smoothed-values-p is true)
—
Note: see Section 7.3 of “Time Series: A Biostatistical Introduction” by Diggle, 1990

Package: sapa.
Source: filtering.lisp.

Function: factorial (k) ¶

given an integer k, returns k!

Package: sapa.
Source: basic-math.lisp.

Function: fast-forward-backward-ls (time-series p &key start end center-data ar-coeffs pseudo-reflection-coeffs) ¶

given
[1] time-series (required)
==> a vector containing a real-valued or complex-valued time series x_t
[2] p (required)
==> autoregressive model order;
p should be an integer > 0 and < end - start
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series; if nil, the effect of this function is to return
a copy of the relevant portion of time-series
[6] AR-coeffs (keyword; a vector of length p)
<== estimates of AR coefficients phi_{1,p}, ..., phi_{p,p} [7] pseudo-reflection-coeffs (keyword; a vector of length p) <== sequence of reflection coefficients computed stepwise by the algorithm, but these do not correspond to the estimated phi_{k,p} (even if the estimated AR model is stationary)
uses the forward/backward least squares method
to estimate the phi’s in the model
x_t = phi_{1,p} x_{t-1} + ... + phi_{p,p} x_{t-p} + e_t and returns
[1] AR-coeffs, a vector containing phi_{1,p}, ..., phi_{p,p} [2] estimate of the innovations variance, i.e.,
the variance of the e_t’s
[3] pseudo-reflection-coeffs
—
Note: see Section 9.7 of the SAPA book;
this function is an adaptation of
the Fortran routine modcovar, pp. 258-60,
“Digital Spectral Analysis with Applications”
by Marple, 1987

Package: sapa.
Source: parametric.lisp.

Function: fft! (complex-vector &key n) ¶

given:
[1] complex-vector (required)
<=> a vector of real or complex-valued numbers [2] N (keyword; length of complex-vector)
==> number of points (must be a power of 2) computes the discrete Fourier transform of complex-vector using a fast Fourier transform algorithm and
returns:
[1] complex-vector, with contents replaced by
the discrete Fourier transform of the input, namely, N-1
X(n) = SUM x(t) exp(-i 2 pi n t/N) t=0
—
Note: see Equation (110a) of the SAPA book
with the sampling time set to unity

Package: sapa.
Source: dft-and-fft.lisp.

Function: filter-time-series (time-series the-filter &key start end technique result) ¶

given
[1] time-series (required)
==> a vector containing a time series
x_0, x_1, ..., x_{N-1}
[2] the-filter (required)
==> a vector containing the filter coefficients g_0, g_1, ..., x_{K-1}
[3] start (keyword; 0)
==> start index of time-series to be used
[4] end (keyword; length of time-series)
==> 1 + end index of time-series to be used
[5] technique (keyword; :fastest)
==> if :fastest, tries to pick fastest method; if :fft, uses fft-based method;
if :direct, uses direct method
[6] result (keyword; vector of appropriate length) <== vector to contain filtered time series K-1
y_t = SUM g_k x_{t+K-1-k}, t = 0, ..., N-K+1 k=0
returns
[1] result, a vector containing the filtered time series [2] the number of values in the filtered time series —
Note: result can be the same as time-series

Package: sapa.
Source: filtering.lisp.

Function: filter-time-series-direct (time-series the-filter &key start end result) ¶

given
[1] time-series (required)
==> a vector containing a time series
x_0, x_1, ..., x_{N-1}
[2] the-filter (required)
==> a vector containing the filter coefficients g_0, g_1, ..., x_{K-1}
[3] start (keyword; 0)
==> start index of time-series to be used
[4] end (keyword; length of time-series)
==> 1 + end index of time-series to be used
[5] result (keyword; vector of appropriate length) <== vector to contain filtered time series K-1
y_t = SUM g_k x_{t+K-1-k}, t = 0, ..., N-K+1 k=0
returns
[1] result, a vector containing the filtered time series [2] the number of values in the filtered time series —
Note: result can be the same as time-series

Package: sapa.
Source: filtering.lisp.

Function: filter-time-series-fft (time-series the-filter &key start end fft-size verbose-p result) ¶

given
[1] time-series (required)
==> a vector containing a time series
x_0, x_1, ..., x_{N-1}
[2] the-filter (required)
==> a vector containing the filter coefficients
g_0, g_1, ..., x_{K-1}
[3] start (keyword; 0)
==> start index of time-series to be used
[4] end (keyword; length of time-series)
==> 1 + end index of time-series to be used
[5] fft-size (keyword; 4 * power of 2 that is ceiling for filter length) ==> size of fft’s to be used (must be a power of 2)
[6] verbose-p (keyword; nil)
==> if t, prints line after each block of data is processed;
if nil, prints nothing
[7] result (keyword; vector of appropriate length)
<== vector to contain filtered time series
K-1
y_t = SUM g_k x_{t+K-1-k}, t = 0, ..., N-K+1 k=0
returns
[1] result, a vector containing the filtered time series
[2] the number of values in the filtered time series
—
Note: result can be the same as time-series

Package: sapa.
Source: filtering.lisp.

Function: find-peak-of-ar-sdf-using-quadratic-approx (f_1 f_2 f_3 ar-coeffs &key sampling-time db-tolerance) ¶

given
[1] f_1 (required)
==> frequency f_1 such that f_1 < f_2 and S(f_1) < S(f_2),
where S(.) is the sdf associated with AR-coeffs
[2] f_2 (required)
==> middle frequency
[3] f_3 (required)
==> frequency f_3 such that f_3 > f_2 and S(f_3) < S(f_2)
[4] AR-coeffs (required)
==> vector with real-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[5] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[6] dB-tolerance (keyword; 0.1)
==> convergence criterion
returns
[1] estimate of frequency of peak/valley in sdf
—
Note: for details on this method, see pages 20-21 of Adby and Dempster, “Introduction to Optimization Methods”; note in particular that we search the inverse of the AR portion of the spectrum instead of the spectrum itself in the belief that the quadratic approximation is better with this reformulation

Package: sapa.
Source: parametric.lisp.

Function: find-peak-or-valley-of-sdf-using-bisection+newton-raphson (f-left f-right ersatz-acvs &key sampling-time n accuracy maximum-number-of-iterations) ¶

given
[1] f-left (required)
==> left bracket for frequency of peak/valley
[2] f-right (required)
==> right bracket for frequency of peak/valley
[3] ersatz-acvs (required)
==> vector of length N with acvs (or acs) s_0 to s_{N-1} corresponding to sdf (only elements 1 to N-1 are used) [4] sampling-time (keyword; 1.0)
==> positive number
[5] N (keyword; length of ersatz-acvs)
==> positive integer
[6] accuracy (keyword; 10.0 * single-float-epsilon)
==> passed to bisection-with-Newton-Raphson
[7] maximum-number-of-iterations (keyword; 20)
==> passed to bisection-with-Newton-Raphson
returns
[1] estimate of frequency of peak/valley in sdf
[2] number of iterations required
—
Note: searches for peak using a combination of
bisection and Newton-Raphson;
see pages 479–80 and 524–5 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: fisher-g-statistic (time-series &key center-data start end alpha) ¶

Package: sapa.
Source: harmonic.lisp.

Function: forward-backward-ls (time-series p &key start end center-data ar-coeffs) ¶

Package: sapa.
Source: parametric.lisp.

Function: forward-ls (time-series p &key start end center-data ar-coeffs) ¶

Package: sapa.
Source: parametric.lisp.

Function: gauss-legendre-quadrature (lower-limit upper-limit n) ¶

given
[1] lower-limit (required)
==> lower limit of integration
[2] upper-limit (required)
==> upper limit of integration
[3] N (required)
==> number of points to be computed
in Gauss-Legendre quadrature returns
[1] an N-dimensional vector of abscissas points [2] an N-dimensional vector of weights
—
Note: this function is based on gauleg, Section 4.5, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: generate-ar-time-series (coeffs variance sample-size &key process-variance-p list-of-lower-order-phi list-of-lower-order-pev result) ¶

given
[1] coeffs (required)
==> sequence of length p with AR coefficients:
x_t = coeffs_0*x_{t-1} + coeffs_1*x_{t-2}
+ ... + coeffs_{p-1}*x_{t-p} + e_t
(see Equation (392a) in the SAPA book;
the coefficients can be real or complex-valued)
[2] variance (required)
==> process variance or innovations variance
(see keyword process-variance-p)
[3] sample-size (required)
==> length of generated time series
[4] process-variance-p (keyword; t)
==> if t, variance is taken to be process variance
if nil, variance is taken to be innovations variance
[5] list-of-lower-order-phi (keyword; nil)
==> to bypass call to step-down-Levinson-Durbin-recursions (useful for multiple realizations)
[6] list-of-lower-order-pev (keyword; nil)
==> to bypass call to step-down-Levinson-Durbin-recursions
[7] result (keyword; vector of length sample-size)
<== vector with simulated series
generates realization of zero mean normally distributed AR(p) process and returns
[1] result, vector of length sample-size with realization
[2] list-of-lower-order-phi (can be used on subsequent calls
to this function to bypass call to step-down-Levinson-Durbin-recursions)
[3] list-of-lower-order-pev (can be also used on subsequent calls) —
Note: this function generates the proper stationary initial conditions

Package: sapa.
Source: random.lisp.

Function: generate-backward-innovations (time-series ar-coeffs &key start end center-data result) ¶

given
[1] time-series (required)
==> a vector containing a real-valued
time series x_t
[2] AR-coeffs (required)
==> vector with real-valued AR coefficients phi_{j,p} for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2} + ... + phi_{p,p} * x_{t-p} + e_t
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series (the vector time-series is not altered)
[6] result (keyword; vector of appropriate length)
<== vector to contain backward innovations p
b_t = x_t - SUM phi_{j,p} x_{t+j}, t = 1, ..., N-p j=1
returns
[1] result, i.e., the backward innovations

Package: sapa.
Source: parametric.lisp.

Function: generate-forward-innovations (time-series ar-coeffs &key start end center-data result) ¶

given
[1] time-series (required)
==> a vector containing a real-valued
time series x_t
[2] AR-coeffs (required)
==> vector with real-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series (the vector time-series is not altered)
[6] result (keyword; vector of appropriate length)
<== vector to contain forward innovations p
f_t = x_{t+p} - SUM phi_{j,p} x_{t-j}, t = 1, ..., N - p j=1
returns
[1] result, i.e., the fprward innovations

Package: sapa.
Source: parametric.lisp.

Function: generate-ma-time-series (coeffs variance sample-size &key process-variance-p result) ¶

given
[1] coeffs (required)
==> sequence of length q with MA coefficients:
x_t = e_t - coeffs_0*e_{t-1}
- coeffs_1*e_{t-2}
- ... - coeffs_{q-1}*e_{t-q}
(see Equation (43a) in the SAPA book)
[2] variance (required)
==> process variance or innovations variance
(see keyword process-variance-p)
[3] sample-size (required)
==> length of generated time series
[4] process-variance-p (keyword; t)
==> if t, variance is taken to be process variance
if nil, variance is taken to be innovations variance
[5] result (keyword; vector of length sample-size)
<== vector with simulated series
generates realization of zero mean normally distributed MA(q) process and returns
[1] vector of length sample-size with realization

Package: sapa.
Source: random.lisp.

Function: generate-white-noise (n &key distribution result) ¶

given
[1] n (required)
==> a sample size
[2] distribution (keyword; :normal)
==> either a keyword or a function with no arguments that returns a random deviate from a particular distribution. Choices are
:binary :cauchy :chi-square-2 :double-exponential :exponential
:extreme-value :Gaussian (same as :normal) :logistic :lognormal :normal :uniform
[3] result (keyword; vector of length n)
<== a sequence in which results are to be stored return
[1] result, containing n samples from a white noise process with a distribution specified by the keyword distribution

Package: sapa.
Source: random.lisp.

Function: grenander-smoothing-window-bandwidth (lag-window-function max-lag &key sampling-time) ¶

given a lag window function, a maximum lag and the sampling time, returns Grenander’s measure of smoothing window bandwidth
—
Note: see Equations (241c) and (241b) of the SAPA book; unfortunately, because of the square root operation, this measure can be complex-valued for certain lag windows

Package: sapa.
Source: nonparametric.lisp.

Function: hanning-data-taper! (a-time-series &key taper-parameter normalization result) ¶

calls cosine-data-taper! with taper-parameter set to 1.0

Package: sapa.
Source: tapers.lisp.

Function: hermitian-transpose (a-matrix &key result) ¶

given
[1] A (required)
==> a 2d matrix
[2] result (keyword; new 2d array of appropriate size)
<== a 2d matrix to contain Hermitian transpose of a-matrix returns
[1] Hermitian transpose of a-matrix (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: histogram (sequence-of-deviates &key number-of-bins left-of-first-bin right-of-last-bin scale-as-density-p result) ¶

given
[1] sequence-of-deviates (required)
==> a sequence of real-valued numbers
[2] number-of-bins (keyword; 10)
==> number of bins in histogram
[3] left-of-first-bin (keyword; min of sequence-of-deviates)
==> leftmost value of first bin
[4] right-of-last-bin (keyword; max of sequence-of-deviates)
==> rightmost value of last bin
[5] scale-as-density-p (keyword; t)
==> if t, histogram is scaled as a density;
otherwise, cell counts are returned
[6] result (keyword; vector of size number-of-bins)
<== vector to hold the histogram
returns
[1] the vector result, which contains the values for the histogram for sequence-of-deviates (one value for each bin); note that,
if a bin has boundaries a and b, all points x in sequence-of-deviates for which a<=x<b are counted as being in that bin
EXCEPT for the last bin, where the rule is a<=x<=b.
[2] maximum value in the histogram (i.e., result)
[3] leftmost value of first bin
[4] bin-width of bins
[5] the number of unbinned elements in sequence-of-deviates
less than left-of-first-bin
[6] the number of unbinned elements in sequence-of-deviates
greater than right-of-last-bin
—
Note: the value in (svref result 0) is the histogram value
for the interval [leftmost value of first bin,
leftmost value of first bin + bin-width of bins); the value in (svref result 1) is the histogram value
for the interval [leftmost value of first bin + bin-width of bins, leftmost value of first bin + 2*bin-width of bins); etc.

Package: sapa.
Source: basic-statistics.lisp.

Function: huber-weight-function (x &key parameter) ¶

given
[1] x (required)
==> value at which to evaluate Huber’s weight function [2] parameter (keyword; 1.5)
==> tuning parameter
returns
[1] value of Huber’s weight function at x

Package: sapa.
Source: basic-statistics.lisp.

Function: ideal-band-pass-filter-irs (k w-low w-high) ¶

given
[1] k (required)
==> index of member of impulse response sequence (irs) to be calculated (must be an integer)
[2] W-low (required)
==> the low frequency cutoff (in standardized units) [3] W-high (required)
==> the high frequency cutoff (in standardized units so that 0 <= W-low < W-high <= 0.5, the assumed Nyquist frequency).
returns
[1] k-th member of the impulse response sequence
for an ideal band-pass filter

Package: sapa.
Source: filtering.lisp.

Function: ideal-high-pass-filter-irs (k w) ¶

given
[1] k (required)
==> index of member of impulse response sequence (irs) to be calculated (must be an integer)
[2] W (required)
==> the cutoff frequency, standardized such that
0 < W < 0.5 = Nyquist frequency
returns
[1] kth member of the impulse response sequence
for an ideal low-pass filter with cutoff frequency W

Package: sapa.
Source: filtering.lisp.

Function: ideal-low-pass-filter-irs (k w) ¶

Package: sapa.
Source: filtering.lisp.

Function: integrate-sdf (sdf freqs &key fiddle-factor return-integrated-sdf-p result) ¶

given
[1] sdf (required)
==> vector with sdf for a real or complex-valued process computed over a grid of frequencies (the grid
need not be uniform) – note that the sdf values
must be untransformed (e.g., not in decibels)
[2] freqs (required)
==> vector with frequencies over which
sdf has been computed
(must be same size as vector with sdf values)
[3] fiddle-factor (keyword; 2.0)
==> values returned are all multiplied by this factor;
the default of 2 is useful for real-valued processes since these have symmetric two-sided sdf’s.
[4] return-integrated-sdf-p (keyword; nil)
==> if t, integrated sdf as a function of frequency
is computed and returned in result
[5] result (keyword; vector of length sdf)
<== vector with integrated sdf (if return-integrated-sdf-p is t) or nil (if return-integrated-sdf-p is nil)
returns
[1] the integral of the sdf * fiddle-factor
[2] result, i.e., the integrated sdf
if return-integrated-sdf-p is t

Package: sapa.
Source: parametric.lisp.

Function: interquartile-range (the-seq &key start end the-seq-is-ordered-p) ¶

given
[1] the-seq (required)
==> a sequence of real-valued numbers [2] start (keyword; 0)
==> start index of sequence to be used [3] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used [4] the-seq-is-ordered-p (keyword; nil) ==> if t, the-seq is assumed to
be sorted from smallest to largest value; if nil, the-seq will be sorted returns
[1] interquartile range; i.e,
0.75 quantile minus 0.25 quantile

Package: sapa.
Source: basic-statistics.lisp.

Function: inverse-dft! (x &key n sampling-time) ¶

given:
[1] X (required)
<=> a vector of real or complex-valued numbers
[2] N (keyword; length of )
==> number of points in inverse dft
[3] sampling-time (keyword; 1.0)
returns:
[1] X, with contents replaced by
the inverse discrete Fourier transform of X, namely, N-1
x(t) = (N sampling-time)^{-1} SUM X(n) exp(i 2 pi n t/N) n=0
—
Note: see Equation (111a) of the SAPA book

Package: sapa.
Source: dft-and-fft.lisp.

Function: inverse-fft! (complex-vector &key n) ¶

given:
[1] complex-vector (required)
<=> a vector of real or complex-valued numbers
[2] N (keyword; length of )
==> number of points in inverse dft
(must be a power of 2)
computes the inverse discrete Fourier transform of complex-vector using a fast Fourier transform algorithm and
returns:
[1] complex-vector, with contents replaced by
the inverse discrete Fourier transform of
the input X(n), namely,
N-1
x(t) = 1/N SUM X(n) exp(i 2 pi n t/N) n=0
—
Note: see Equation (111a) of the SAPA book
with the sampling time set to unity

Package: sapa.
Source: dft-and-fft.lisp.

Function: iota (start end &key type float-p skip result) ¶

given
[1] start (required)
==> an integer
[2] end (required)
==> an integer >= start
[3] type (keyword; ’vector)
==> type of sequence desired
[4] float-p (keyword; nil)
==> if true, sequence consists of floats
[5] skip (keyword; 1)
==> desired increment between integers in sequence [6] result (keyword; sequence of length (1+ (- start end))) ==> storage space for result
returns
[1] a sequence of length (1+ (/ (- end start) skip)) with numbers start, start + skip, ..., end - skip, end (these are stored in whatever result points to)

Package: sapa.
Source: utilities.lisp.

Function: jenkins-smoothing-window-bandwidth (lag-window-function max-lag &key sampling-time) ¶

given a lag window function, a maximum lag and the sampling time, returns Jenkins’ measure of smoothing window bandwidth
—
Note: see Equation (242c) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: kernel-pdf-estimation (a-seq start-x increment-x n-pdf &key window-width result-pdf result-x) ¶

given
[1] a-seq (required)
==> a sequence of real-valued numbers
[2] start-x (required)
==> first point at which pdf is
to be estimated
[3] increment-x (required)
==> increment between points at which pdf is
to be estimated (i.e., second point is
at start-x + increment-x, third point is
at start-x + 2*increment-x, etc)
[4] n-pdf (required)
==> number of points at which pdf is
to be estimated
[5] window-width (keyword; Silverman’s formula)
==> window width of kernel pdf estimator
[6] result-pdf (keyword; vector of length n-pdf)
<== vector to hold pdf estimate
[7] result-x (keyword; vector of length n-pdf)
<== vector to hold points at which
pdf was estimated
computes a pdf estimate using the normal (Gaussian) kernel and returns
[1] the pdf estimate (in result-pdf)
[2] the points associated with the pdf estimates (in result-x) [3] the window width

Package: sapa.
Source: basic-statistics.lisp.

Function: lag-window-spectral-estimate (acvs lag-window-function &key max-lag n-ts n-nonzero-freqs return-est-for-0-freq-p sampling-time scratch-dft c_h sdf-transformation result-sdf return-frequencies-p freq-transformation result-freq) ¶

given
[1] acvs (required)
==> vector containing autocovariance sequence
[2] lag-window-function (required)
==> function of a single variable that computes the value of the lag window for a given lag
[3] max-lag (keyword; (1- (length acvs)))
==> maximum lag in acvs to be used
[4] N-ts (keyword; length of acvs)
==> length of the time series from which acvs was constructed; this is needed to compute equivalent degrees of freedom [5] N-nonzero-freqs (keyword; :half-next-power-of-2)
==> specifies at how many nonzero frequencies
direct spectral estimate is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [6] return-est-for-0-freq-p (keyword; nil)
==> if t, sdf is computed at zero frequency;
otherwise, it is not computed.
[7] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[8] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[9] C_h (keyword; 1.0)
==> variance inflation factor due to tapering
[10] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[11] result-sdf (keyword; vector of correct length)
<== vector into which lag window spectral estimates are placed; it must be exactly of the length dictated
by N-nonzero-freqs and return-est-for-0-freq-p
[12] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral estimate are computed and returned in result-freq
[13] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[14] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of length dictated by
N-nonzero-freqs and return-est-for-0-freq-p
into which the frequencies associated with the values in result-sdf are placed
returns
[1] result-sdf, a vector holding
the properly transformed sdf
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-sdf
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-sdf
[4] the equivalent degrees of freedom
[5] the smoothing window bandwidth
—
Note: see Section 6.7 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: linear-interpolation! (a-sequence &key interpolation-predicate) ¶

given
[1] a-sequence (required)
<=> a sequence of numbers
[2] interpolation-predicate (keyword; #’zerop) ==> a unitary predicate which, when true, indicates that a value in a-sequence
is to be replaced by a linear interpolation returns
[1] a-sequence, modified with linear interpolates over specified values

Package: sapa.
Source: utilities.lisp.

Function: linearized-upper-trangular->2d-matrix (a &key result) ¶

given
[1] A (required)
==> a vector with an upper triangular matrix stored in linearized form
[2] result (keyword; new 2d array of appropriate size) <== a 2d hermitian matrix filled according
to contents of A
converts linearized form A into 2d hermitian array and returns
[1] result, a 2d hermitian matrix

Package: sapa.
Source: matrix.lisp.

Function: log-of-gamma (xx) ¶

given xx (a real or complex valued number whose real part is greater than 0),
returns the log (base e) of gamma(xx)
—
Note: based upon the discussion in Section 6.1, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: log10 (num) ¶

given
[1] num (required)
==> a number
returns
[1] log_10(num)
—
Note: shorthand for (log num 10)

Package: sapa.
Source: utilities.lisp.

Function: lower-triangular-solve! (a b &key n) ¶

given
[1] A (required)
==> lower n by n triangular matrix
(note: upper superdiagonal part of this matrix is ignored) [2] b (required)
<=> on input, the right-hand side vector;
on output, the solution X to A X = b
[3] n (keyword; length of b)
==> order of matrix A
returns
[4] X, the solution to A X = b, where X is the same as vector which contained b (note that A is left unchanged)

Package: sapa.
Source: matrix.lisp.

Function: m-location-estimate (the-seq &key weighting-functions iterations) ¶

given
[1] the-seq (required)
==> a sequence of numbers
[2] weighting-functions (keyword; Huber and Thomson) ==> a list of two weighting functions
[3] iterations (keyword; ’(10 0))
==> a list of nonegative integers
giving the number of iterations
for each weighting function
returns
[1] m-location estimate for sequence
[2] MAD scale estimate (based upon deviations from m-location estimate)
—
Note: see article by Hogg in Launer and Wilkinson

Package: sapa.
Source: basic-statistics.lisp.

Function: max-of-seq (the-seq &key start end) ¶

Package: sapa.
Source: utilities.lisp.

Function: median-absolute-deviation (the-seq &key location-estimate) ¶

given
[1] the-seq (required)
==> a sequence of real-valued numbers
[2] location-estimate (keyword; median of the-seq) ==> robust estimate of location
returns
[1] the median absolute deviation about location-estimate [2] location-estimate (median of the-seq by default)

Package: sapa.
Source: basic-statistics.lisp.

Function: min-and-max-of-seq (the-seq &key start end) ¶

Package: sapa.
Source: utilities.lisp.

Function: min-of-seq (the-seq &key start end) ¶

Package: sapa.
Source: utilities.lisp.

Function: modified-gram-schmidt! (a-matrix) ¶

given
[1] A (required)
<=> a matrix of real or complex-valued numbers with size m by n with rank N
computes the factorization A = QR, where
Q is of size m by n and has orthonormal columns and R is of size n by n and is upper triangular, and returns
[1] Q
[2] R
—
Note: see Algorithm 5.2.5, p. 219, of Golub and Van Loan, Second Edition, with simple changes to handle matrices with real or complex-valued numbers

Package: sapa.
Source: matrix.lisp.

Function: multiply-2-polynomials (polynomial-1 polynomial-2 &key degree-of-1 degree-of-2 product-polynomial) ¶

given
[1] polynomial-1 (required)
==> sequence of length n+1 with real or
complex-valued numbers giving the n+1
coefficients of a polynomial of nth order;
(elt polynomial-1 i) = coefficient of z^(n-i)
[2] polynomial-2 (required)
==> another sequence representing another polynomial
[3] degree-of-1 (keyword; (1- (length polynomial-1)))
==> degree of first polynomial
[4] degree-of-2 (keyword; (1- (length polynomial-2)))
==> degree of second polynomial
[5] product-polynomial (keyword; array of length (+ degree-of-1 degree-of-2 1)) <== a sequence with product of two polynomials
returns
[1] product-polynomial, an sequence with coefficients
of polynomial given by the product of
polynomial-1 and polynomial-2
—
Note: this routine works for a polynomial p represented either by
p(0) + p(1)*z + ... + p(degp)*z^degp
or by
p(0)*z**degp + p(1)*z**(degp-1) + ... + p(degp)

Package: sapa.
Source: basic-math.lisp.

Function: multiply-matrix-and-scalar (a-matrix scalar &key result) ¶

given
[1] a-matrix (required)
==> a 2d matrix
[2] scalar (required)
==> an arbitrary number
[3] result (keyword; new matrix of same size as a-matrix) <== a matrix to contain product of a-matrix and scalar returns
[1] product of a-matrix and scalar (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: multiply-matrix-and-vector (a-matrix b-vector &key result) ¶

given
[1] a-matrix (required)
==> a 2d matrix
[2] b-vector (required)
==> a vector, with dimensions such that
the product of a-matrix and b-vector is defined [3] result (keyword; new vector of appropriate size)
<== a vector to contain product of a-matrix and b-vector returns
[1] product of a-matrix and b-vector (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: multiply-polynomials (&rest polys) ¶

given
[1] sequences representing any number of polynomials (required) returns
[1] a sequence representing their product
—
Note: this function was written by Andrew G. Bruce

Package: sapa.
Source: basic-math.lisp.

Function: multiply-sequences (&rest seqs) ¶

given
[1] a arbitrary number of sequences of numbers, all of the same size
returns
[1] a new sequence formed by multiplying the sequences together on an element by element basis

Package: sapa.
Source: utilities.lisp.

Function: multiply-two-matrices (a-matrix b-matrix &key result) ¶

given
[1] a-matrix (required)
==> a 2d matrix
[2] b-matrix (required)
==> another 2d matrix, with dimensions such that the product of a-matrix and b-matrix is defined [3] result (keyword; new 2d array of appropriate size) <== a 2d matrix to contain product of two matrices returns
[1] product of two matrices (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: multitaper-spectral-estimate (time-series list-of-data-tapers &key center-data start end n-tapers n-nonzero-freqs return-est-for-0-freq-p sampling-time scratch-dft recenter-after-tapering-p restore-power-option-p sdf-transformation result-sdf return-eigenpspectra-p return-frequencies-p freq-transformation result-freq) ¶

given
[1] time-series (required)
==> a sequence of time series values
[2] list-of-data-tapers (required)
==> a list of orthonormal data tapers,
each of length (- end start)
[3] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, time-series is not centered
[4] start (keyword; 0)
==> start index of sequence to be used
[5] end (keyword; length of time-series)
==> 1 + end index of sequence to be used
[6] N-tapers (keyword; length of list-of-data-tapers)
==> number of data tapers to be used in list-of-data-tapers
[7] N-nonzero-freqs (keyword; :half-next-power-of-2)
==> specifies at how many nonzero frequencies
multitaper spectral estimate is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size;
:Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size]
[8] return-est-for-0-freq-p (keyword; nil)
==> if t, sdf is computed at zero frequency;
otherwise, it is not computed.
[9] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[10] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[11] recenter-after-tapering-p (keyword; t)
==> if t and data-taper is a function,
centers tapered series by subtracting
off its sample mean
[12] restore-power-option-p (keyword; t)
==> if t and data-taper is a function,
normalizes tapered series to have same
sum of squares as before tapering
[13] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[14] result-sdf (keyword; vector of correct length)
<== vector into which multitaper spectral estimate is placed;
it must be exactly of the length dictated
by N-nonzero-freqs and return-est-for-0-freq-p
[15] return-eigenpspectra-p (keyword; t)
==> if t, individual eigenspectra are returned in a list
(each eigenspectrum in the list is associated with
the corresponding taper in list-of-data-tapers)
[16] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral estimate
are computed and returned in result-freq
[17] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[18] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of length N-nonzero-freqs (if return-est-for-0-freq-p is nil) or N-nonzero-freqs +1 (if return-est-for-0-freq-p is t)
into which the frequencies associated with the values
in result-sdf are placed
returns
[1] result-sdf, a vector holding
the properly transformed multitaper spectral estimate
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-sdf,
or
nil (if return-frequencies-p is nil)
[3] the length of the vector result-sdf
[4] a list of untransformed eigenspectra (return-eigenpspectra-p is t), or
nil (if return-eigenpspectra-p is nil)
—
Note: see Section 7.1 of the SAPA book

Package: sapa.
Source: multitaper.lisp.

Function: n-applications-of-three-point-smoother (a-seq n) ¶

given
[1] a-seq (required)
==> a sequence of length 2*n + 1 or greater [2] n (required)
==> positive integer indicating the number of times the three-point smoother is to be applied
returns
[1] the result of repetitively smoothing a-seq using the function three-point-smoother

Package: sapa.
Source: filtering.lisp.

Function: newton-raphson (f f-prime x-left x-right &key accuracy maximum-number-of-iterations prevent-bracket-jumping-p) ¶

given
[1] f (required)
==> a function with a single argument
[2] f-prime (required)
==> another function with a single argument, this one being the first derivative of f [3] x-left (required)
==> left-hand bracket for the desired root; i.e., left-hand bracket <= desired root [4] x-right (required)
==> right-hand bracket for the desired root; i.e., desired root <= right-hand bracket [5] accuracy (keyword; (* 10.0 single-float-epsilon)) ==> desired relative accuracy for computed rood [6] maximum-number-of-iterations (keyword; 20) ==> maximum number of iterations
[7] prevent-bracket-jumping-p (keyword; t)
==> if t, allows Newton-Raphson to continue if it jumps out of the interval
[x-left, x-right];
if nil, jumping out of the interval causes an error to be signaled
returns
[1] a root of f in [x-left, x-right];
i.e., a value x in that interval
such that f(x) = 0
[2] the number of iterations required
—
Note: this function is based loosely on rtnewt, Section 9.4, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: next-power-of-2 (n) ¶

given
[1] n (required)
==> an integer
returns
[1] an integer power of 2 greater than or equal to n

Package: sapa.
Source: utilities.lisp.

Function: nyquist-frequency->sampling-time (nyquist-frequency) ¶

given a Nyquist frequency, returns the associated sampling-time —
Note: see page 98 of the SAPA book

Package: sapa.
Source: utilities.lisp.

Function: one-sided-freq->two-sided-freq (one-sided-freq &key result) ¶

given a vector of N frequencies
0, f_1, ..., f_{N-1},
returns the vector of 2N-1 frequencies -f_{N-1}, ..., -f_1, 0, f_1, ..., f_{N-1}

Package: sapa.
Source: nonparametric.lisp.

Function: one-sided-sdf->two-sided-sdf (one-sided-sdf &key result) ¶

given a one-sided sdf
S(0), S(f_1), ..., S_(f_{N-1}) of length N,
returns the two-sized sdf
S_(-f_{N-1}), ..., S(-f_1), S(0), S(f_1), ..., S_(f_{N-1}) of length 2N-1, where S_(-f_k) = S_(f_k)

Package: sapa.
Source: nonparametric.lisp.

Function: ordinary-least-squares-cholesky (dependent-variable list-of-independent-variables &key compute-residuals-p result) ¶

given
[1] dependent-variable (required)
==> a vector
[2] list-of-independent-variables (required)
==> a list of either vectors or functions
(must be ALL vectors or ALL functions)
[3] compute-residuals-p (keyword; nil)
==> if t, residuals are computed
[4] result (keyword; new array if compute-residuals-p is t; otherwise nil) <== storage space for residuals
(not used unless compute-residuals-p is true)
returns
[1] vector with estimated parameters
[2] residuals
—
Note: uses Lisp versions of Cholesky factorization routines
from linpack

Package: sapa.
Source: basic-statistics.lisp.

Function: ordinary-least-squares-q-r (dependent-variable list-of-independent-variables &key compute-residuals-p compute-standard-errors-p compute-correlation-matrix-p residuals) ¶

given
[1] dependent-variable (required)
==> a vector
[2] list-of-independent-variables (required)
==> a list of either vectors, functions or mixture thereof [3] compute-residuals-p (keyword; nil)
==> if t, residuals are computed
[4] compute-standard-errors-p (keyword; nil)
==> if t, standard errors for parameter estimates are computed, along with residuals (even if compute-residuals-p is nil) [5] compute-correlation-matrix-p (keyword; nil)
==> if t, correlation matrix for parameter estimates is computed, along with residuals and standard errors (even if either of their associated keywords is nil)
[6] residuals (keyword; nil or vector)
<== storage space for residuals
(nil unless either compute-residuals-p, compute-standard-errors-p or
compute-correlation-matrix-p is true)
returns
[1] vector with parameter estimates
[2] vector with residuals
[2] standard error of residuals
[3] vector with standard errors of parameter estimates
[4] correlation matrix
—
Note: this routine is based on the discussion
in “Nonlinear Regression Analysis and Its Applications”
by Bates and Watts, Wiley, 1988.

Package: sapa.
Source: basic-statistics.lisp.

Function: papoulis-bandwidth->m (b_w &key sampling-time) ¶

given desired smoothing window bandwidth B_W and sampling time, returns
[1] window parameter m required to approximately achieve B_W using the Papoulis lag window
[2] actual B_W achieved
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: papoulis-lag-window (tau m) ¶

given the lag tau and window parameter m,
returns the value of the Papoulis lag window
—
Note: see equation near bottom of page 266 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: papoulis-m->bandwidth (m &key sampling-time) ¶

given window parameter m and sampling time,
returns bandwidth B_W for the Papoulis smoothing window —
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: papoulis-n-m->degrees-of-freedom (n m &key c_h) ¶

given sample size N, window parameter m and variance inflation factor C_h, returns equivalent degrees of freedom nu for Papoulis lag window
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: parzen-bandwidth->m (b_w &key sampling-time) ¶

given desired smoothing window bandwidth B_W and sampling time, returns
[1] window parameter m required to approximately achieve B_W using the Parzen lag window
[2] actual B_W achieved
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: parzen-lag-window (tau m) ¶

given the lag tau and window parameter m, returns the value of the Parzen lag window
—
Note: see the equation on page 265 of the SAPA book or Priestley, page 443, Equation (6.2.82)

Package: sapa.
Source: nonparametric.lisp.

Function: parzen-m->bandwidth (m &key sampling-time) ¶

given window parameter m and sampling time, returns bandwidth B_W for the Parzen smoothing window —
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: parzen-n-m->degrees-of-freedom (n m &key c_h) ¶

given sample size N, window parameter m and variance inflation factor C_h, returns equivalent degrees of freedom nu for Parzen lag window
—
Note: see Table 269 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: periodogram (time-series &key center-data start end n-nonzero-freqs return-est-for-0-freq-p sampling-time scratch-dft sdf-transformation result-sdf return-frequencies-p freq-transformation result-freq) ¶

given
[1] time-series (required)
==> a vector of time series values
[2] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series; if nil, time-series is not centered
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of time-series)
==> 1 + end index of vector to be used
[5] N-nonzero-freqs (keyword; :half-next-power-of-2)
==> specifies at how many nonzero frequencies periodogram is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [6] return-est-for-0-freq-p (keyword; nil)
==> if t, periodogram is computed at zero frequency; otherwise, it is not computed.
[7] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book) [8] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[9] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[10] result-sdf (keyword; vector of correct length)
<== vector into which periodogram is placed;
it must be exactly of the length dictated
by N-nonzero-freqs and return-est-for-0-freq-p [11] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the periodogram are computed and returned in result-freq
[12] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true) [13] result-freq (keyword; nil or vector of correct length) <== not used if return-frequencies-p nil; otherwise, vector of length dictated by
N-nonzero-freqs and return-est-for-0-freq-p
into which the frequencies associated with the values in result-sdf are placed
returns
[1] result-sdf, a vector holding
the properly transformed periodogram
[2] result-freq (if return-frequencies-p is t),
a vector holding the properly transformed
frequencies associated with values in result-sdf
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-sdf
—
Note: see Section 6.3 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: periodogram-at-one-frequency (time-series freq &key center-data start end sampling-time) ¶

Package: sapa.
Source: harmonic.lisp.

Function: postcolor-spectral-estimate (precolored-sdf-estimate prewhitening-filter sample-size &key n-nonzero-freqs includes-est-for-0-freq-p scratch-dft sdf-transformation result-sdf) ¶

given
[1] precolored-sdf-estimate (required)
==> vector containing sdf estimate to be postcolored;
note that this estimate is assumed to be untransformed (i.e., not expressed in dB, etc)
[2] prewhitening-filter (required)
==> vector with coefficients of prewhitening filter
[3] sample-size (required)
==> length of the time series from which precolored-sdf-estimate was constructed; this is needed to get corresponding
grid of frequencies
[4] N-nonzero-freqs (keyword; :half-next-power-of-2)
==> specifies at how many nonzero frequencies precolored-sdf-estimate was computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size;
:Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size]
[5] includes-est-for-0-freq-p (keyword; nil)
==> if t, first element of precolored-sdf-estimate corresponds to zero frequency
[6] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[7] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[8] result-sdf (keyword; vector of correct length)
<== vector into which postcolored sdf estimate is placed;
it must be exactly the same length as precolored-sdf-estimate returns
[1] result-sdf, a vector holding
the postcolored sdf estimate
—
Note: see Equation (438) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: power-of-2 (n) ¶

given
[1] n (required)
==> an integer
returns
[1] nil if n is not a power of 2
– or –
m if n = 2^m for a positive integer m

Package: sapa.
Source: utilities.lisp.

Function: predicted-y-at-x (x intercept slope) ¶

given
[1] x (required)
==> a number
[2] intercept (required) ==> intercept of a line [3] slope (required) ==> slope of a line returns
[1] intercept + slope*x

Package: sapa.
Source: basic-statistics.lisp.

Function: print-1-or-2-d-array (an-array &key tag format-control-for-array-element) ¶

given
[1] an-array (required)
==> a one-dimensional or two-dimensional array [2] tag (keyword; ‘array’)
==> an optional tag to be printed
along with array elements
[3] format-control-for-array-element (keyword; ‘~F’) ==> format control for a single array element prints the elements of an-array and
returns
[1] an-array

Package: sapa.
Source: matrix.lisp.

Function: print-rows-of-nxm-matrix (an-nxm-matrix &key format-control-for-array-element) ¶

given
[1] an-nxm-matrix (required)
==> a two-dimensional array
[3] format-control-for-array-element (keyword; ‘~F’) ==> format control for a single array element prints the elements of the 2d array and
returns
[1] an-nxm-matrix

Package: sapa.
Source: matrix.lisp.

Function: q-q-plot (y-vals x-vals &key n x-vals-sorted-p y-vals-sorted-p) ¶

given
[1] y-vals (required)
==> a sequence or function
[2] x-vals (required)
==> a sequence or function
[3] n (keyword; 256 if y-vals is a function, length of y-vals otherwise) ==> positive integer
[4] x-vals-sorted-p (keyword; t if x-vals is a function, nil otherwise) ==> a flag indicating whether x-vals is already sorted
[5] y-vals-sorted-p (keyword; t if y-vals is a function, nil otherwise) ==> a flag indicating whether y-vals is already sorted
return
[1] y values needed to create a q-q-plot for y-vals
[2] x values
—
Note: For details, see Chapter 6 of “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner and Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: q-r! (a-matrix) ¶

same as modified-Gram-Schmidt!

Package: sapa.
Source: matrix.lisp.

Function: quantile-of-chi-square-2-distribution (p) ¶

given
[1] p (required)
==> a number > 0 and < 1
returns
[1] p-th quantile of chi-square distribution with 2 degrees of freedom —
Note: Equation (31), P. 640 of Chave, Thomson, and Ander (1987)

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-of-chi-square-distribution (nu p &key accuracy-level) ¶

given
[1] nu (required)
==> degrees of freedom
[2] p (required)
==> a number > 0 and < 1
[3] accuracy-level (keyword; :quick)
if :quick, gives quick approximation;
if :accurate, give accurate, but computationally
expensive, approximation
returns
[1] p-th quantile of chi-square distribution with nu degrees of freedom —
Note: for :quick, see Table 6.4, page 225,
“Graphical Methods for Data Analysis”
by Chambers, Cleveland, Kleiner, & Tukey;
if :accurate, see AS 91, Applied Statistics

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-of-exponential-distribution (p) ¶

given
[1] p (required)
==> a number > 0 and < 1
returns
[1] p-th quantile of exponential distribution with mean 1 —
Note: Table 6.4, page 225, “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner, & Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-of-gamma-distribution (alpha p) ¶

given
[1] alpha (required)
==> shape parameter for gamma distribution
[2] p (required)
==> a number > 0 and < 1
returns
[1] p-th quantile of standard gamma distribution
—
Note: Table 6.4, page 225, “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner, & Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-of-kolmogorov-test-statistic (sample-size &key significance-level) ¶

given
[1] sample-size (required)
==> a positive integer
[2] significance-level (keyword; 0.95)
==> 0.99, 0.98, 0.95, 0.90, or 0.80;
0.75 is also ok if sample-size > 40
returns
[1] quantile of two-sided Kolmogorov test statistic —
Note: see Table 14, page 462, of Conover (2nd edition, 1980); Stephens (1974); and Diggle (1990, page 55); significance-level is currently limited to one of these values: 0.99, 0.98, 0.95, 0.90, or 0.80;
if sample-size is greater than 40, 0.75 is also ok

Package: sapa.
Source: nonparametric.lisp.

Function: quantile-of-normal-distribution (p &key accuracy-level) ¶

given
[1] p (required)
==> a number > 0 and < 1
[2] accuracy-level (keyword; :quick)
==> if :quick, gives quick approximation;
if :better, gives slower, but better, approximation; if :accurate, uses slowest, but more accurate, approximation;
returns
[1] quantile of standard normal distribution;
—
Note: for :quick, see Table 6.5, page 227,
“Graphical Methods for Data Analysis”
by Chambers, Cleveland, Kleiner, & Tukey;
for :better, see Sections 26.2.22 and 26.2.23
of Abramowitz and Stegun;
for :accurate, see AS 111 by Beasley and Springer, Applied Statistics, 1977, vol. 26, p.118

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-of-ordered-seq (the-seq p) ¶

given
[1] the-seq (required)
==> a sequence of real-valued numbers,
ordered from smallest to largest
[2] p (required)
==> a percentile; i.e., 0 <= p <= 1
returns
[1] the sample quantile for p
—
Note: see Section 2.2 of “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner, and Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: quantile-plot (a-seq &key a-seq-sorted-p) ¶

given
[1] a-seq (required)
==> any sequence of real-valued numbers
[2] a-seq-sorted-p (keyword; nil)
==> if t, a-seq is already sorted;
if nil, a copy of a-seq is sorted
for use by the function
returns
[1] sequence with sample quantiles for a-seq
[2] sequence with corresponding percentiles
—
Note: see Section 2.2 of “Graphical Methods for Data Analysis” by Chambers, Cleveland, Kleiner, and Tukey

Package: sapa.
Source: basic-statistics.lisp.

Function: ranorm () ¶

returns a random deviate from a normal distribution with zero mean and unit variance

Package: sapa.
Source: random.lisp.

Function: ranorms (n &key result) ¶

given:
[1] n (required)
==> number of normal random deviates
to be generated
[2] result (keyword; vector of length n)
<== vector to hold random deviates returns:
[1] result, a vector with n normal random deviates (i.e., a realization of length n of a white noise process from a normal distribution)

Package: sapa.
Source: random.lisp.

Function: reflection-coeffs->ar-coeffs (reflection-coeffs &key p scratch result) ¶

given
[1] reflection-coeffs (required)
==> vector of length p with real-valued reflection coefficients
phi_{1,1}, phi_{2,2}, ... , phi_{p,p}
[2] p (keyword; length of reflection-coeffs)
==> AR model order
[3] scratch (keyword; vector of length p)
==> vector of size p used for intermediate results [4] results (keyword; vector of length p)
<== vector of size p into which are placed
the AR coefficients phi_{j,p} for model
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2} + ... + phi_{p,p} * x_{t-p} + e_t returns
[1] results, i.e., the AR coefficients
—
Note: see Section 9.4 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: reflection-coeffs->variance (reflection-coeffs innovations-variance &key p) ¶

given
[1] reflection-coeffs (required)
==> vector of length p with real-valued reflection coefficients phi_{1,1}, phi_{2,2}, ... , phi_{p,p} [2] innovations-variance (required)
==> innovations variance of the process [3] p (keyword; length of reflection-coeffs) ==> AR model order
returns
[1] variance of the process
—
Note: this is a recursive application of Equation (404c) of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: regression-with-ar-errors (time-series ind-vars p &key ar-coeff-estimator maximum-number-of-iterations eps trace-ar-parameter-estimates-p trace-ls-parameter-estimates-p) ¶

given
[1] time-series (required)
==> a vector with dependent variables
[2] ind-vars (required)
==> a list of vector(s) with independent variable(s) [3] p (required)
==> autoregressive order
[4] AR-coeff-estimator (keyword; #’burg-algorithm)
==> AR estimation procedure
[5] maximum-number-of-iterations (keyword; 5)
==> ... like I said ...
[6] eps (keyword; 1.0e-7)
==> a small number – used to test for convergence in estimates of both regression and AR coefficients [7] trace-AR-parameter-estimates-p (keyword; nil)
==> if t, results of each iteration
on AR parameters are printed
[8] trace-LS-parameter-estimates-p (keyword; nil)
==> if t, results of each iteration
on least squares parameters are printed
returns
[1] estimates of least squares coefficients
[2] estimates of AR coefficients
[3] variance of residuals
[4] either number of iterations required for convergence or nil if maximum number of iterations completed but convergence not yet achieved
—
Note: this function is based on Newton, TIMESLAB, page 241; it has NOT been thoroughly tested (particularly with regard to the convergence criterion),
so a heavy dose of the usual “caveat emptor”
is appropriate here!!!

Package: sapa.
Source: parametric.lisp.

Function: running-median (time-series k &key result) ¶

given
[1] time-series (required)
==> a sequence of numbers
[2] K (required)
==> positive integer giving the number of points in the running median
[3] result (keyword; vector of appropriate length) <== a sequence to hold running medians
of time series
return
[1] result, the vector of running medians
of K consecutive points

Package: sapa.
Source: filtering.lisp.

Function: sample-cepstrum (log-spectrum &key sampling-time zero-frequency-p nyquist-frequency-p result) ¶

given
[1] log-spectrum (required)
==> a vector containing log spectrum
[2] sampling-time (keyword; 1.0)
==> the sample time (i.e., delta t)
[3] zero-frequency-p (keyword; nil)
==> if t, the first element of log-spectrum
is associated with 0 frequency;
if nil, first element goes with
lowest nonzero frequency
[4] Nyquist-frequency-p (keyword; nil)
==> if t, the last element of log-spectrum
is associated with Nyquist frequency;
if nil, last element goes with
a frequency just less than Nyquist
[5] result (keyword; vector of appropriate length)
<== vector to hold sample cepstrum
returns
[1] result, i.e., the sample cepstrum from lag 0 to lag N_U
where N_U = length of log-spectrum - 1 if zero-frequency-p is t or = length of log-spectrum if zero-frequency-p is nil —
Note: see Equation 282 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: sample-correlation-coefficient (seq-1 seq-2 &key start end) ¶

given
[1] seq-1 (required)
==> a sequence of real-valued numbers [2] seq-2 (required)
==> another sequence of real-valued numbers; should have the same length as seq-1 [3] start (keyword; 0)
==> start index of sequence to be used [4] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used returns
[1] sample correlation coefficient
between two sequences

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-from-a-function (a-function &key seq-of-x-values x0 delta-x n) ¶

given
[1] a-function (required)
==> a function to be sampled from
[2] seq-of-x-values (keyword; ’())
==> sequence of values at which a-function
is to be sampled (default ’())
[3] x0 (keyword; 0.0)
==> point of first value to be sampled
[4] delta-x (keyword; 1.0)
==> increment between points
[5] n (keyword; length of seq-of-x-values)
==> number of samples
returns
[1] an array with the values of a-function
at a specified set of points; and
[2] an array with the specified set of points.
—
Note that the specified set of points either is in seq-of-x-values – if it is non-nil – or is given by
x0, x0 + delta-x, x0 + 2*delta-x, ..., x0 + (n-1)*delta-x

Package: sapa.
Source: utilities.lisp.

Function: sample-mean (the-seq &key start end) ¶

given
[1] the-seq (required)
==> a sequence of real or complex-valued numbers [2] start (keyword; 0)
==> start index of sequence to be used
[3] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used returns
[1] sample mean of the specified numbers
in the-seq

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-mean-and-variance (the-seq &key start end) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-median (the-seq &key start end the-seq-is-ordered-p) ¶

given
[1] the-seq (required)
==> a sequence of real-valued numbers [2] start (keyword; 0)
==> start index of sequence to be used [3] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used [4] the-seq-is-ordered-p (keyword; nil) ==> if t, the-seq is assumed to
be sorted from smallest to largest value; if nil, the-seq will be sorted returns
[1] sample median
[2] minimum value in sequence
[3] maximum value
[4] sorted sequence

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-skewness-and-kurtosis (the-seq &key start end) ¶

given
[1] the-seq (required)
==> a sequence of real-valued numbers [2] start (keyword; 0)
==> start index of sequence to be used [3] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used returns
[1] sample skewness of the specified numbers in the-seq
[2] sample kurtosis
[3] sample mean
[4] sample variance

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-variance (the-seq &key start end) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: sample-variogram (time-series times) ¶

given:
[1] time-series (required)
==> a vector containing the time series [2] times (required)
==> a vector containing the associated times returns
[1] the sample variogram
[2] associated lags
—
Note: see Diggle’s book

Package: sapa.
Source: acvs.lisp.

Function: sampling-time->nyquist-frequency (sampling-time) ¶

given a sampling time, returns the associated Nyquist frequency —
Note: see page 98 of the SAPA book

Package: sapa.
Source: utilities.lisp.

Function: sdf->sdf-with-accurate-peaks (sdf freqs ar-coeffs innovations-variance &key sampling-time sdf-transformation search-method db-tolerance accuracy maximum-number-of-iterations) ¶

given
[1] sdf (required)
==> vector with sdf for a real-valued process
computed over a grid of frequencies (the grid
need not be uniform) – note that the sdf values
can be either untransformed or transformed via
an order preserving transformation (such as decibels)
[2] freqs (required)
==> vector with frequencies corresponding to values
in sdf (must be same size as vector with sdf values)
[3] AR-coeffs (required)
==> vector with real-valued AR coefficients phi_{j,p}
for an AR(p) model of order p:
x_t = phi_{1,p} * x_{t-1} + phi_{2,p} * x_{t-2}
+ ... + phi_{p,p} * x_{t-p} + e_t
[4] innovations-variance (required)
==> innovations variance of the process
[5] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[6] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform any newly computed values of the sdf
[7] search-method (keyword; :quadratic-approx)
==> selects between two methods to search
for the location of peaks;
if set to :quadratic-approx, a quadratic approximation is used; if set to :bisection+Newton-Raphson, an interval search using a combination of bisection and Newton-Raphson is used [8] dB-tolerance (keyword; 0.1)
==> convergence criterion (used if search-method
is :quadratic-approx)
[9] accuracy (keyword; 10 * single-float-epsilon)
==> convergence criterion (used if search-method
is :bisection+Newton-Raphson)
[10] maximum-number-of-iterations (keyword; 20)
==> controls the number of iterations (used if search-method
is :bisection+Newton-Raphson)
returns
[1] a vector with values of sdf merged
with an additional set of values
chosen to represent peaks accurately
[2] the corresponding augmented vector of frequencies
[3] the length of the two vector returned
—
Note: see pages 524–5 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: secant-method (f x-left x-right &key accuracy maximum-number-of-iterations) ¶

given
[1] f (required)
==> a function with a single argument
[2] x-left (required)
==> left-hand bracket for the desired root; i.e., left-hand bracket <= desired root [3] x-right (required)
==> right-hand bracket for the desired root; i.e., desired root <= right-hand bracket [4] accuracy (keyword; (* 10.0 single-float-epsilon)) ==> desired relative accuracy for computed rood [5] maximum-number-of-iterations (keyword; 50) ==> maximum number of iterations
returns
[1] a root of f in [x-left, x-right];
i.e., a value x in that interval
such that f(x) = 0
[2] the number of iterations required
—
Note: this function is based loosely on rtsec, Section 9.2, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: sign (a1 a2) ¶

implementation of Fortran SIGN function

Package: sapa.
Source: utilities.lisp.

Function: simple-numerical-integration (f a b &key accuracy maximum-number-of-iterations) ¶

given
[1] f (required)
==> a function with a single argument
[2] a (required)
==> left-hand limit for numerical integration [3] b (required)
==> right-hand limit for numerical integration i.e., a < b
[4] accuracy (keyword; 1.0e-6)
==> desired relative accuracy for computed rood [5] maximum-number-of-iterations (keyword; 20) ==> maximum number of iterations
returns
[1] the integral of f over the interval [a, b] [2] the number of iterations required
—
Note: this function is based on qtrap,
Section 4.2, Numerical Recipes, Second Edition

Package: sapa.
Source: basic-math.lisp.

Function: simulate-time-series-from-sdf (n-series sdf &key sampling-time n-total result) ¶

given
[1] n-series (required)
==> length of time series to be simulated
[2] sdf (required)
==> spectral density function (sdf) defined for
0 <= f <= 1/(2.0 sampling-time) – the
sdf is assumed to be two-sided and symmetric
about f = 0
[3] sampling-time (keyword; 1.0)
==> the assumed sampling time (delta t)
[4] n-total (keyword; 4 * next power of 2 for n-series)
==> a power of 2 controlling degree of accuracy
of the approximation (the larger, the better –
see Percival, 1992, for details)
[5] result (keyword; vector of length n-series)
<== a vector to contain simulated time series
returns
[1] a vector of length n-series generated from sdf
—
Note: the method used here is an approximate frequency domain technique; in particular, it will NOT simulate the DC component correctly, so beware of using this function in studies where the process mean is of important

Package: sapa.
Source: random.lisp.

Function: smoothing-window-for-lag-window-spectral-estimate (sample-size lag-window-function &key n-nonzero-freqs sampling-time scratch-dft smooth-wind-transformation result-smooth-wind return-frequencies-p freq-transformation result-freq) ¶

given
[1] sample-size (required)
==> sample size for which smoothing window is to be computed [2] lag-window-function (required)
==> function of a single variable that computes the value
of the lag window for a given lag
[3] N-nonzero-freqs (keyword; :twice-next-power-of-2)
==> specifies at how many nonzero frequencies
smoothing window is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [4] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[5] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[6] smooth-wind-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-smooth-wind
[7] result-smooth-wind (keyword; vector of correct length)
<== vector into which smoothing window values are placed;
it must be exactly of the length dictated by N-nonzero-freqs [8] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the smoothing window are computed and returned in result-freq
[9] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[10] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of N-nonzero-freqs +1 into which
the frequencies associated with the values
in result-smooth-wind are placed
returns
[1] result-smooth-wind, a vector holding
the properly transformed smoothing window
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-smooth-wind
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-smooth-wind
—
Note: see equation below Equation (237c) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: spectral-window-for-direct-spectral-estimate (sample-size &key n-nonzero-freqs sampling-time scratch-dft data-taper data-taper-parameters spec-wind-transformation result-spec-wind return-frequencies-p freq-transformation result-freq) ¶

given
[1] sample-size (required)
==> sample size for which spectral window is to be computed [2] N-nonzero-freqs (keyword; :twice-next-power-of-2)
==> specifies at how many nonzero frequencies
spectral window is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [3] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[4] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[5] data-taper (keyword; nil)
==> nil or a tapering function
[6] data-taper-parameters (keyword)
==> parameters for tapering function (not used
if data-taper is nil)
[7] spec-wind-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-spec-wind
[8] result-spec-wind (keyword; vector of correct length)
<== vector into which spectral window values are placed;
it must be exactly of the length dictated by N-nonzero-freqs [9] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral window are computed and returned in result-freq
[10] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
[11] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of N-nonzero-freqs +1 into which
the frequencies associated with the values
in result-spec-wind are placed
returns
[1] result-spec-wind, a vector holding
the properly transformed spectral window
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-spec-wind
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-spec-wind
—
Note: see equation below Equation (207a) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: spectral-window-for-lag-window-spectral-estimate (sample-size lag-window-function &key n-nonzero-freqs sampling-time scratch-dft data-taper data-taper-parameters spec-wind-transformation result-spec-wind return-frequencies-p freq-transformation result-freq) ¶

given
[1] sample-size (required)
==> sample size for which spectral window is to be computed [2] lag-window-function (required)
==> function of a single variable that computes the value
of the lag window for a given lag
[3] N-nonzero-freqs (keyword; :twice-next-power-of-2)
==> specifies at how many nonzero frequencies
spectral window is to be computed – choices are: :half-next-power-of-2
==> 1/2 * power of two >= sample size; :next-power-of-2
==> power of two >= sample size; :twice-next-power-of-2
==> 2 * power of two >= sample size; :Fourier
==> just at Fourier frequencies
– or –
any power of 2 >= 1/2 * [power of two >= sample size] [4] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[5] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[6] data-taper (keyword; nil)
==> nil or a tapering function
[7] data-taper-parameters (keyword)
==> parameters for tapering function (not used
if data-taper is nil)
[8] spec-wind-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-spec-wind
[9] result-spec-wind (keyword; vector of correct length)
<== vector into which spectral window values are placed;
it must be exactly of the length dictated by N-nonzero-freqs [10] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral window are computed and returned in result-freq
[11] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[12] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of N-nonzero-freqs +1 into which
the frequencies associated with the values
in result-spec-wind are placed
returns
[1] result-spec-wind, a vector holding
the properly transformed spectral window
[2] result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the properly transformed frequencies
associated with values in result-spec-wind
– or –
nil (if return-frequencies-p is nil)
[3] the length of the vector result-spec-wind
—
Note: see equation below Equation (244a) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: spofa! (a &key n) ¶

given
[1] A (required)
<=> real symmetric positive definite matrix (this gets trashed)
[2] n (keyword; (array-dimensions a))
==> size of matrix to be factored calculates the upper triangular matrix U
of the Cholesky decomposition A = LU,
where L = U^T, and
returns
[1] U, stored in upper triangular part of A

Package: sapa.
Source: matrix.lisp.

Function: sposl! (a b &key n) ¶

given
[1] A (required)
==> real symmetric positive definite matrix
AFTER it has been crunched by spofa!
[2] b (required)
<=> the right-hand side vector on input;
on output, this gets replaced by the solution X [3] N (keyword; length of b)
==> order of matrix A (default is length of b) returns
[1] X, the solution to A X = b; note that X is the same as the vector which contained b

Package: sapa.
Source: matrix.lisp.

Function: standard-normal-pdf (x) ¶

given x, returns value of standard normal pdf at x

Package: sapa.
Source: basic-statistics.lisp.

Function: step-down-levinson-durbin-recursions (coeffs variance &key process-variance-p) ¶

given
[1] coeffs (required)
==> sequence of length p with AR coefficients:
x_t = coeffs_0*x_{t-1} + coeffs_1*x_{t-2}
+ ... + coeffs_{p-1}*x_{t-p} + e_t
(see Equation (392a) in the SAPA book;
the coefficients can be real or complex-valued)
[2] variance (required)
==> process variance or innovations variance
(see keyword process-variance-p)
[3] process-variance-p (keyword; t)
==> if t, variance is taken to be process variance
if nil, variance is taken to be innovations variance
computes best linear prediction coefficients of orders 1, 2, ..., p-1 and prediction error variances of orders 0 (process variance), 1, ..., p and returns
[1] list of vectors with best linear prediction coefficients
going from order 1 to order p;
[2] list of prediction error variances going from order 0 to order p —
Note: see item [4] of the Comments and Extensions
to Section 9.4 of the SAPA book. The values returned by
this function can be used to set the keyword parameters list-of-lower-order-phi and list-of-lower-order-pev in
the function generate-ar-time-series

Package: sapa.
Source: random.lisp.

Function: subtract-two-matrices (a-matrix b-matrix &key result) ¶

given
[1] a-matrix (required)
==> a 2d matrix
[2] b-matrix (required)
==> a 2d matrix, with dimensions the same
as a-matrix
[3] result (keyword; new vector of appropriate size) <== a matrix to contain result of subtracting b-matrix from a-matrix
returns
[1] a-matrix minus b-matrix (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: sum (the-seq &key start end) ¶

Package: sapa.
Source: utilities.lisp.

Function: sum-of-squares (the-seq &key start end) ¶

Package: sapa.
Source: utilities.lisp.

Function: supplied-data-taper! (a-time-series &key taper-parameter normalization result) ¶

given
[1] a-time-series (required)
<=> a vector containing a time series;
this vector is modified UNLESS keyword result
is bound to a different vector
[2] taper-parameter (keyword; vector with Hanning taper) ==> a vector containing the supplied data taper
(must be the same length as a-time-series); unmodified upon return
[3] normalization (keyword; :unity)
==> if :unity, taper normalized such that
its sum of squares is equal to unity (Equation (208a)); if :N, taper normalized such that
its sum of squares is equal to the number of points in the time series
[4] result (keyword; a-time-series)
<=> a vector to contain time series multiplied
by the supplied data taper
returns
[1] a vector containing the tapered time series
[2] C_h, the variance inflation factor
computed using Equation (251b) in the SAPA book

Package: sapa.
Source: tapers.lisp.

Function: symmetry-plot (a-seq &key a-seq-sorted-p) ¶

given
[1] a-seq (required)
==> any sequence of real-valued numbers [2] a-seq-sorted-p (keyword; nil)
==> if t, a-seq is already sorted; if nil, a copy of a-seq is sorted for use by the function
returns
[1] y values for a symmetry plot for a-seq [2] x values for a symmetry plot for a-seq

Package: sapa.
Source: basic-statistics.lisp.

Function: tail-area-of-normal-distribution (q &key q-to-infinity-p) ¶

given
[1] q (required)
==> a quantile
[2] q-to-infinity-p (keyword; nil)
==> if t, return integral from q to +infinity; if nil, return integral from -infinity to q return
tail area of the standard norm from
either q to +infinity (if q-to-infinity-p is true) or -infinity to q (if q-to-infinity-p is nil) —
see Algorithm AS-66, Applied Statistics,
1973, vol. 22, no. 3

Package: sapa.
Source: basic-statistics.lisp.

Function: thomson-weight-function (x &key beta symmetric-version) ¶

given
[1] x (required)
==> value at which to evaluate Thomson’s
weight function
[2] beta (keyword; 1.0)
==> tuning parameter
[3] symmetric-version (keyword; t)
==> one-sided or two-sided down weightings
returns
[1] value of Thomson’s weight function at x
—
Note: Equation (27), p. 637 of Chave, Thomson, and Ander (1987)

Package: sapa.
Source: basic-statistics.lisp.

Function: three-point-smoother (a-seq) ¶

given a sequence of length N,
returns a sequence of length N-2 formed by filtering the input sequence with a three-point filter with coefficients 1/4, 1/2 and 1/4
—
Note: see Section 5.7 of the SAPA book

Package: sapa.
Source: filtering.lisp.

Function: time-series-bandwidth (acvs &key sampling-time) ¶

given
[1] acvs (required)
==> a vector of length N with values of
the acvs (or acs) from lag 0 to N-1
[2] sampling-time (keyword; 1.0)
==> the sampling time
returns
[1] unbiased estimate of trace bandwidth
(tilde B_T in Equation (280))
[2] biased estimate of trace bandwidth
(hat B_T in equation just above Equation (28))) —
Note: see Section 6.14 of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: trace-matrix (a-matrix) ¶

given a square matrix, returns its trace

Package: sapa.
Source: matrix.lisp.

Function: transfer-function-for-filter (the-filter &key tf-transformation actual-index-of-1st-filter-coeff n-fft return-frequencies-p nyquist-frequency result-tf result-freq) ¶

given
[1] the-filter (required)
==> a vector of filter coefficients
[2] tf-transformation (keyword; mod squared in dB with 0 mapped to -100 dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all of the elements of the transfer function
[3] actual-index-of-1st-filter-coeff (keyword; 0)
==> the filter coefficient in (aref the-filter 0) is assumed
to have an index equal to whatever is given here
(this is only needed if the phase of the transfer function
is needed)
[4] N-fft (keyword; 4 * (next-power-of-2 (length the-filter)))
==> the length of vector to be used in the fast Fourier transform
– the larger this is, the finer the grid of frequencies
over which the transfer function is computed; this number
MUST be a power of 2.
[5] return-frequencies-p (keyword; nil)
==> if t, the frequencies associated with the transfer function
are computed and returned in result-freq
[6] Nyquist-frequency (keyword; 0.5)
==> the Nyquist frequency
[7] result-tf (keyword; vector of length (1+ (/ N-fft 2)))
<== vector of length (1+ (/ N-fft 2))
into which the properly transformed transfer function
is placed (returned by the function)
[8] result-freq (keyword; vector of length (1+ (/ N-fft 2)) if return-frequencies-p t) <== vector of length (1+ (/ N-fft 2))
into which the frequencies associated with the values
in result-tf are placed if return-frequencies-p is true
(returned by the function)
returns
[1] result-tf, a vector holding
the properly transformed transfer function
[2] nil (if return-frequencies-p is nil) or
result-freq (if return-frequencies-p is t),
where result-freq is a vector holding
the frequencies associated with values
in result-tf
—
Note: see Section 5.3 of the SAPA book

Package: sapa.
Source: filtering.lisp.

Function: transform-a-sequence (a-function the-seq) ¶

given
[1] a-function (required)
==> a function with one argument
[2] the-seq (required)
==> a sequence of numbers
returns
[1] a sequence of numbers obtained by applying a-function to each element of the-seq

Package: sapa.
Source: utilities.lisp.

Function: transform-a-sequence! (a-function the-seq &key result) ¶

given
[1] a-function (required)
==> a function with one argument
[2] the-seq (required)
==> a sequence of numbers
[3] result (keyword; the-seq)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by applying a-function to each element of the-seq

Package: sapa.
Source: utilities.lisp.

Function: transpose (a-matrix &key result) ¶

given
[1] A (required)
==> a 2d matrix
[2] result (keyword; new 2d array of appropriate size) <== a 2d matrix to contain transpose of a-matrix returns
[1] transpose of a-matrix (placed in result)

Package: sapa.
Source: matrix.lisp.

Function: triangular-convergence-factors (k filter-length) ¶

Package: sapa.
Source: filtering.lisp.

Function: trig-prolate-tapers (n number-of-tapers &key taper-parameter print-progress-p compute-true-eigenvalues-p) ¶

given
[1] N (required)
the sample size
[2] number-of-tapers (required)
number of orthonormal trig prolate tapers
to be computed; currently restricted to
one of the following maximum values:
2 if taper-parameter is 2;
4 if taper-parameter is 3;
5 if taper-parameter is 4;
7 if taper-parameter is 5
[3] taper-parameter (keyword; 4.0)
NW, the duration-half-bandwidth product;
currently restricted to one of the
following integers: 2, 3, 4, 5
(must also be such that 0 < NW/N < 1/2)
[4] print-progress-p (keyword; nil)
if t, prints a dot after each taper
has been computed
[5] compute-true-eigenvalues-p (keyword; nil)
if t, returns eigenvalues for eigenproblem
of Equation (378) of the SAPA book;
if nil, returns nil
returns
[1] a list of length number-of-tapers of N dimensional vectors with orthonormal trig prolate data tapers of orders
0, 1, ..., number-of-tapers - 1;
[2] a vector of length number-of-tapers with
eigenvalues if compute-true-eigenvalues-p is t;
nil if if compute-true-eigenvalues-p is nil
—
Note: computes the trig prolate approximation to
the dpss tapers (see Section 8.4 of the SAPA book)

Package: sapa.
Source: multitaper.lisp.

Function: trigamma (x &key x-recursion) ¶

given
[1] x (required)
==> a positive number
[2] x-recursion (keyword; 2.0)
==> if x < x-recursion,
recursive formula is used
returns
[1] value of trigamma function at x
—
Note: expansion 6.4.12 plus recurrence 6.4.6
of Abramowitz and Stegun;
better accuracy can be obtained by increasing x-recursion —10.0 to 30.0 is probably a useful upper limit

Package: sapa.
Source: basic-math.lisp.

Function: two-step-burg-algorithm (time-series p &key start end center-data ar-coeffs approximate-mses reflection-coeffs forward-prediction-errors backward-prediction-errors exact-mses) ¶

given
[1] time-series (required)
==> a vector containing a real-valued or
complex-valued time series x_t
[2] p (required)
==> autoregressive model order;
p should be an EVEN integer > 0 and < end - start
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, the effect of this function is to return
a copy of the relevant portion of time-series
[6] AR-coeffs (keyword; a vector of length p)
<== estimates of AR coefficients phi_{1,p}, ..., phi_{p,p}
[7] approximate-MSEs (keyword; a vector of length p+1)
<== estimates of innovations variance (mean square errors)
for models of order 0, 1, ..., p (the innovations variance
for the zeroth order model is the sample variance)
[8] reflection-coeffs (keyword; a vector of length p)
<== estimates of reflection coefficients phi_{1,1}, ..., phi_{p,p} [9] forward-prediction-errors (keyword; a vector of length end - start - p) <== computed forward prediction errors
[10] backward-prediction-errors (keyword; a vector of length end - start - p) <== computed backward prediction errors
[11] exact-MSEs (keyword; a vector of length p+1)
<== another set of estimates of innovations variance
for models of order 0, 1, ..., p; these estimates
are based on Equation (419a) of the SAPA book
uses the two step Burg algorithm to estimate the phi’s in the model
x_t = phi_{1,p} x_{t-1} + ... + phi_{p,p} x_{t-p} + e_t
and returns
[1] AR-coeffs, a vector containing phi_{1,p}, ..., phi_{p,p}
[2] estimate of the innovations variance, i.e.,
the variance of the e_t’s; this number is also given in
(elt approximate-MSEs p)
[3] approximate-MSEs
[4] reflection-coeffs
[5] forward-prediction-errors
[6] backward-prediction-errors
[7] exact-MSEs
—
Note: see Section 9.5 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: upper-triangular-solve! (a b &key n) ¶

given
[1] A (required)
==> upper n by n triangular matrix
(note: lower subdiagonal part of this matrix is ignored) [2] b (required)
<=> on input, the right-hand side vector;
on output, the solution X to A X = b
[3] n (keyword; length of b)
==> order of matrix A
returns
[4] X, the solution to A X = b, where X is the same as vector which contained b (note that A is left unchanged)

Package: sapa.
Source: matrix.lisp.

Function: var-predicted-mean-at-x (x covariance-matrix) ¶

given
[1] x (required)
==> a number
[2] covariance-matrix (required)
==> covariance matrix for estimated intercept and slope as returned by weighted-linear-least-squares returns
[1] the variance of the predicted mean of y at x
—
Note: see page 56, Draper and Smith, 1966

Package: sapa.
Source: basic-statistics.lisp.

Function: var-predicted-y-at-x (x residual-variance covariance-matrix) ¶

given
[1] x (required)
==> a number
[2] residual-variance (required)
==> the residual variance as returned
by weighted-linear-least-squares
[3] covariance-matrix (required)
==> covariance matrix for estimated
intercept and slope as returned
by weighted-linear-least-squares
returns
[1] the variance of the predicted value of y
at x
—
Note: see Equation (1.4.8), p. 24, Draper and Smith, 1966

Package: sapa.
Source: basic-statistics.lisp.

Function: weighted-linear-least-squares (y &key versus weights compute-residuals-p compute-covariance-matrix-p residuals) ¶

given
[1] y (required)
==> a sequence with values of y_k’s, the dependent variable. [2] versus (keyword; equally spaced & centered values)
==> a sequence or function giving values of x_k’s,
the independent variable
[3] weights (keyword; nil)
==> if vector supplied, these are used as weights
on the observations (nil implies that all y_k’s
are equally weighted)
[4] compute-residuals-p (keyword; nil)
==> if t, residuals are computed
[5] compute-covariance-matrix-p (keyword; nil)
==> if t, calculates and returns 2x2 var/covar matrix [6] residuals (keyword; nil or vector)
<== a sequence to be stuffed with the residuals
(not used unless compute-residuals-p is true)
fits model y_k = alpha + beta * x_k, and
returns
[1] estimate of intercept alpha
[2] estimate of slope beta
[3] estimate of residual variance
[4] residuals (if compute-residuals-p is true)
[5] covariance matrix for parameter estimates
(if compute-covariance-matrix-p is true)
—
Note: see Chapter 2 of Draper and Smith, 1966

Package: sapa.
Source: basic-statistics.lisp.

Function: weighted-mean (the-seq &key weights start end) ¶

given
[1] the-seq (required)
==> a sequence of real or complex-valued numbers [2] weights (keyword; nil)
==> a sequence with (- end start) values
to be used as weights; if set to nil, equal weights for all numbers
is assumed
[3] start (keyword; 0)
==> start index of sequence to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of sequence to be used returns
[1] the weighted average of the specified numbers in the-seq

Package: sapa.
Source: basic-statistics.lisp.

Function: window-width-from-silverman (a-seq) ¶

given a-seq,
returns the window width for kernel pdf estimation given on page 48, Equation (3.31), of Silverman, 1986

Package: sapa.
Source: basic-statistics.lisp.

Function: wosa-spectral-estimate (time-series block-size &key proportion-of-overlap oversampling-factor center-data start end return-est-for-0-freq-p sampling-time scratch-dft data-taper data-taper-parameters restore-power-option-p sdf-transformation result-sdf return-sdf-estimates-for-each-block-p return-frequencies-p freq-transformation result-freq) ¶

given
[1] time-series (required)
==> a vector of real-valued numbers
[2] block-size (required)
==> a power of two
[3] proportion-of-overlap (keyword; 0.5)
==> number greater than 0 and less than 1
[4] oversampling-factor (keyword; 1)
==> a factor that controls the number of frequencies
at which the wosa spectral estimate is computed;
this factor should be an integer power of two
such as 1, 2, 4, etc; for example,
1 yields Fourier frequencies for block-size;
2 yields grid twice as fine as Fourier frequencies;
4 yields griid 4 times as fine as Fourier frequencies; etc.
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, time-series is not centered
[6] start (keyword; 0)
==> start index of vector to be used
[7] end (keyword; length of time-series)
==> 1 + end index of vector to be used
[8] return-est-for-0-freq-p (keyword; nil)
==> if t, sdf is computed at zero frequency;
otherwise, it is not computed.
[9] sampling-time (keyword; 1.0)
==> sampling time (called delta t in the SAPA book)
[10] scratch-dft (keyword; vector of correct length)
==> vector in which the in-place dft is done
[11] data-taper (keyword; #’Hanning-data-taper!)
==> a tapering function or nil
[12] data-taper-parameters (keyword; nil)
==> parameters for tapering function (not used
if data-taper is nil); the default of nil
is appropriate for the Hanning data taper
because it does not have any parameters
[13] restore-power-option-p (keyword; t)
==> if t and data-taper is non-nil,
normalizes tapered series to have same
sum of squares as before tapering
[14] sdf-transformation (keyword; #’convert-to-dB)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-sdf
[15] result-sdf (keyword; vector of correct length)
<== vector into which wosa sdf estimate is placed;
it must be EXACTLY of the length dictated
by block-size, oversampling-factor and return-est-for-0-freq-p [16] return-sdf-estimates-for-each-block-p (keyword; t)
==> if t, individual spectra for each block are returned in a list; note that these spectra are untransformed
(i.e., the option sdf-transformation applies only
to the final wosa estimate)
[17] return-frequencies-p (keyword; t)
==> if t, the frequencies associated with the spectral estimate are computed and returned in result-freq
[18] freq-transformation (keyword; nil)
==> a function of one argument or nil;
if bound to a function, the function is used
to transform all elements of result-freq
(ignored unless return-frequencies-p is true)
[19] result-freq (keyword; nil or vector of correct length)
<== not used if return-frequencies-p nil; otherwise,
vector of length dictated by
block-size, oversampling-factor and return-est-for-0-freq-p into which the frequencies associated with the values
in result-sdf are placed
returns
[1] wosa spectral estimate
[2] associated frequencies
[3] equivalent degrees of freedom
[4] list of individual direct spectral estimates

Package: sapa.
Source: nonparametric.lisp.

Function: x*y (x y) ¶

given
[1] x (required)
==> a sequence of numbers
[2] y (required)
==> a sequence of numbers
returns
[1] a vector of numbers obtained by multiplying corresponding elements of x and y

Package: sapa.
Source: utilities.lisp.

Function: x*y! (x y &key result) ¶

given
[1] x (required)
==> a sequence of numbers
[2] y (required)
==> a sequence of numbers
[3] result (keyword; x)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by multiplying corresponding elements of x and y

Package: sapa.
Source: utilities.lisp.

Function: x+b (x b) ¶

given
[1] x (required)
==> a sequence of numbers
[2] b (required)
==> a number
returns
[1] a vector of numbers obtained by adding b to each element of x

Package: sapa.
Source: utilities.lisp.

Function: x+b! (x b &key result) ¶

given
[1] x (required)
==> a sequence of numbers
[2] b (required)
==> a number
[3] result (keyword; x)
<== a sequence of numbers
returns
[1] a sequence of numbers obtained by adding b to each element of x

Package: sapa.
Source: utilities.lisp.

Function: x+y (x y) ¶

given
[1] x (required)
==> a sequence of numbers
[2] y (required)
==> a sequence of numbers
returns
[1] a vector of numbers obtained by adding x and y together element by element

Package: sapa.
Source: utilities.lisp.

Function: x+y! (x y &key result) ¶

Package: sapa.
Source: utilities.lisp.

Function: x-y (x y) ¶

given
[1] x (required)
==> a sequence of numbers
[2] y (required)
==> a sequence of numbers
returns
[1] a vector of numbers obtained by subtracting elements of y from corresponding elements of x

Package: sapa.
Source: utilities.lisp.

Function: x-y! (x y &key result) ¶

Package: sapa.
Source: utilities.lisp.

Function: yule-walker-algorithm-given-acvs (acvs p &key ar-coeffs approximate-mses reflection-coeffs) ¶

given
[1] acvs (required)
==> a vector containing values of the acvs
for a real-valued time series x_t
from lag 0 up to (and including) p
[2] p (required)
==> autoregressive model order;
p should be an integer > 0 and < end - start
[3] AR-coeffs (keyword; a vector of length p)
<== estimates of AR coefficients phi_{1,p}, ..., phi_{p,p}
[4] approximate-MSEs (keyword; a vector of length p+1)
<== estimates of innovations variance (mean square errors)
for models of order 0, 1, ..., p (the innovations variance for the zeroth order model is the sample variance)
[5] reflection-coeffs (keyword; a vector of length p)
<== estimates of reflection coefficients phi_{1,1}, ..., phi_{p,p} uses the Yule-Walker method to estimate the phi’s in the model
x_t = phi_{1,p} x_{t-1} + ... + phi_{p,p} x_{t-p} + e_t
and returns
[1] AR-coeffs, a vector containing phi_{1,p}, ..., phi_{p,p}
[2] estimate of the innovations variance, i.e.,
the variance of the e_t’s; this number is also given in
(elt approximate-MSEs p)
[3] approximate-MSEs
[4] reflection-coeffs
—
Note: see Sections 9.3 and 9.4 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: yule-walker-algorithm-given-data (time-series p &key start end center-data ar-coeffs approximate-mses reflection-coeffs forward-prediction-errors backward-prediction-errors) ¶

given
[1] time-series (required)
==> a vector containing a real-valued time series x_t
[2] p (required)
==> autoregressive model order;
p should be an integer > 0 and < end - start
[3] start (keyword; 0)
==> start index of vector to be used
[4] end (keyword; length of the-seq)
==> 1 + end index of vector to be used
[5] center-data (keyword; t)
==> if t, subtract sample mean from time series;
if a number, subtracts that number from time series;
if nil, the effect of this function is to return
a copy of the relevant portion of time-series
[6] AR-coeffs (keyword; a vector of length p)
<== estimates of AR coefficients phi_{1,p}, ..., phi_{p,p}
[7] approximate-MSEs (keyword; a vector of length p+1)
<== estimates of innovations variance (mean square errors)
for models of order 0, 1, ..., p (the innovations variance
for the zeroth order model is the sample variance)
[8] reflection-coeffs (keyword; a vector of length p)
<== estimates of reflection coefficients phi_{1,1}, ..., phi_{p,p} [9] forward-prediction-errors (keyword; a vector of length end - start - p) <== computed forward prediction errors
[10] backward-prediction-errors (keyword; a vector of length end - start - p) <== computed backward prediction errors
uses the Yule-Walker method to estimate the phi’s in the model
x_t = phi_{1,p} x_{t-1} + ... + phi_{p,p} x_{t-p} + e_t
and returns
[1] AR-coeffs, a vector containing phi_{1,p}, ..., phi_{p,p}
[2] estimate of the innovations variance, i.e.,
the variance of the e_t’s; this number is also given in
(elt approximate-MSEs p)
[3] approximate-MSEs
[4] reflection-coeffs
[5] forward-prediction-errors
[6] backward-prediction-errors
—
Note: see p. 420 of the SAPA book

Package: sapa.
Source: parametric.lisp.

Function: zero-strict-lower-diagonal! (a-matrix) ¶

given a square matrix,
zeros its lower diagonal and returns the modified square matrix

Package: sapa.
Source: matrix.lisp.

Function: zeros-of-polynomial (polynomial &key degree-of-polynomial the-roots maximum-number-of-iterations) ¶

given
[1] polynomial (required)
==> sequence with coefficients of a polynomial;
(elt polynomial 0) must be nonzero
[2] degree-of-polynomial (keyword; (1- (length polynomial))) ==> degree of polynomial
[3] the-roots (keyword; array of length degree-of-polynomial) <== number of derivatives to be evaluated
[4] maximum-number-of-iterations (keyword; 25)
==> maximum number of iterations
returns
[1] t or nil, where t indicates that all went well, whereas nil indicates that convergence did not occur at end of specificed number of iterations
[2] the-roots, a vector with the required roots
of the polynomial

Package: sapa.
Source: basic-math.lisp.

Previous: Public Interface, Up: Definitions [Contents][Index]

Next: Special variables, Previous: Internals, Up: Internals [Contents][Index]

4.2.1 Constants

Constant: +euler-constant+ ¶

Package: sapa.
Source: basic-math.lisp.

Constant: +log-pi+ ¶

Package: sapa.
Source: basic-math.lisp.

Constant: +ppchi2-aa+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c1+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c10+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c11+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c12+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c13+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c14+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c15+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c16+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c17+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c18+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c19+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c2+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c20+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c21+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c22+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c23+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c24+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c25+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c26+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c27+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c28+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c29+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c3+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c30+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c31+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c32+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c33+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c34+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c35+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c36+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c37+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c38+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c4+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c5+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c6+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c7+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c8+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-c9+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-e+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-pmax+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppchi2-pmin+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-a0+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-a1+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-a2+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-a3+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-b1+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-b2+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-b3+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-b4+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-c0+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-c1+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-c2+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-c3+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-d1+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +ppnd-d2+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Constant: +sapa-10-over-log-10+ ¶

Package: sapa.
Source: utilities.lisp.

Constant: +sapa-2-pi+ ¶

Package: sapa.
Source: utilities.lisp.

Constant: +sapa-4-time-exp-of-1-over-4+ ¶

Package: sapa.
Source: random.lisp.

Constant: +sapa-4-time-exp-of-minus-1-point-35+ ¶

Package: sapa.
Source: random.lisp.

Constant: +sapa-minus-2-pi+ ¶

Package: sapa.
Source: utilities.lisp.

Constant: +sapa-sqrt-8-over-e+ ¶

Package: sapa.
Source: random.lisp.

Constant: +sqrt-of-two-pi+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Next: Ordinary functions, Previous: Constants, Up: Internals [Contents][Index]

4.2.2 Special variables

Special Variable: *abscissas-32-point* ¶

Package: sapa.
Source: multitaper.lisp.

Special Variable: *sapa-cached-pre-fft-arrays* ¶

Package: sapa.
Source: dft-and-fft.lisp.

Special Variable: *weights-32-point* ¶

Package: sapa.
Source: multitaper.lisp.

Special Variable: +coefficents-for-log-of-gamma+ ¶

Package: sapa.
Source: basic-math.lisp.

Special Variable: +nr-gser-eps+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Special Variable: +nr-gser-itmax+ ¶

Package: sapa.
Source: basic-statistics.lisp.

Special Variable: +use-pre-fft-with-cache-p+ ¶

Package: sapa.
Source: dft-and-fft.lisp.

Previous: Special variables, Up: Internals [Contents][Index]

4.2.3 Ordinary functions

Function: absolute-sum-of-vector-elements (vector) ¶

Package: sapa.
Source: parametric.lisp.

Function: as-111 (p) ¶

adapted from AS 111 — FORTRAN routine ppnd

Package: sapa.
Source: basic-statistics.lisp.

Function: as-91 (p degrees-of-freedom) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: as-91-block-1 (ch a g c) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: as-91-block-4 (ch xx c p g) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: bessi0-nr (x) ¶

Package: sapa.
Source: tapers.lisp.

Function: binary-search-internal (value ordered-seq start end lower-test upper-test) ¶

Package: sapa.
Source: utilities.lisp.

Function: calculate-number-of-blocks (sample-size block-size proportion-of-overlap) ¶

Package: sapa.
Source: nonparametric.lisp.

Function: complex-of-absolutes (z) ¶

Package: sapa.
Source: basic-math.lisp.

Function: continued-fraction-representation-for-incomplete-gamma (a x) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: dpss->eigenvalue (dpss nw) ¶

given dpss (a vector of length N) and NW, computes the corresponding eigenvalue using the method of Exercise [8.1], page 390, of the SAPA book

Package: sapa.
Source: multitaper.lisp.

Function: eigenvalues-and-vectors-of-sym-tridiag-matrix (diag off-diag &key maximum-number-of-iterations return-eigenvectors-p z) ¶

given
[1] diag (required)
==> sequence of diagonal elements
(length of, say, n)
[2] off-diag (required)
==> sequence of off-diagonal elements
(length of n-1)
[3] maximum-number-of-iterations (keyword; 30)
==> maximum number of iterations
[4] return-eigenvectors-p (keyword; t)
==> if true, returns eigenvalues and eigenvectors; if nil, just do the eigenvalues (this is faster) [5] z (keyword; n by n diagonal matrix)
==> usually bound to output from Householder-reduction-of-real-sym-matrix returns
[1] vector with n eigenvalues
(NOT necessarily ordered by size)
[2] if return-eigenvectors-p is true, an n by n array whose jth column is the eigenvector corresponding to the jth eigenvalue; if return-eigenvectors-p is nil, that’s what you get!
—
This is based upon tqli in Numerical Recipes

Package: sapa.
Source: multitaper.lisp.

Function: equivalent-dof-for-wosa (n n_s n_b vector-with-data-taper) ¶

given the sample size N, the block size N_S, the number of blocks N_B, and the values of the data taper,
returns the equivalent degrees of freedom for wosa
using Equation (292b) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: equivalent-dof-for-wosa-standard-case (n_s) ¶

given number of blocks N_S,
returns the equivalent degrees of freedom for wosa with 50% overlap and Hanning data taper
using Equation (294) of the SAPA book

Package: sapa.
Source: nonparametric.lisp.

Function: eval-poly-2 (polynomial x) ¶

Package: sapa.
Source: parametric.lisp.

Function: fast-tridiag-eigenvalue->dpss! (eigenvalue order-of-taper diag off-diag &key eps maximum-number-of-iterations b) ¶

Package: sapa.
Source: multitaper.lisp.

Function: find-symmetric-frequency (f_1 f_2 f_3 f_n) ¶

Package: sapa.
Source: parametric.lisp.

Function: flip-sign-of-coefficients! (a-sequence) ¶

Package: sapa.
Source: parametric.lisp.

Function: generate-initial-guess-at-dpss (n order-of-taper &key half-size-p result) ¶

Package: sapa.
Source: multitaper.lisp.

Function: generate-tri-prolate-taper (n generating-function) ¶

Package: sapa.
Source: multitaper.lisp.

Function: get-n-dft (n-nonzero-freqs sample-size) ¶

Package: sapa.
Source: nonparametric.lisp.

Function: get-n-freqs (n-nonzero-freqs sample-size return-est-for-0-freq-p) ¶

Package: sapa.
Source: nonparametric.lisp.

Function: get-offset-to-kth-block (sample-size block-size number-of-blocks k) ¶

Package: sapa.
Source: nonparametric.lisp.

Function: h-func (f g x) ¶

Package: sapa.
Source: parametric.lisp.

Function: householder-reduction-of-real-sym-matrix! (real-sym-matrix &key prepare-for-eigenvectors-p) ¶

given
[1] real-sym-matrix (required)
==> real, symmetric matrix (n by n)
[2] prepare-for-eigenvectors-p (keyword; t)
==> if true, crunch real-sym-matrix for use with eigenvalues-and-vectors-of-sym-tridiag-matrix returns
[1] n-dimensional vector with diagonal elements of associated tridiagonal matrix
[2] (n-1)-dimensional vector with off-diagonal elements of associated tridiagonal matrix
—
See tred2 in Numerical Recipes

Package: sapa.
Source: multitaper.lisp.

Function: incomplete-gamma (a x) ¶

arguments:
a — parameter value > 0
x — variable >= 0
returns three values:
value of incomplete gamma function at a and x; the numerator (little gamma of a and x); the denominator (gamma of a);
see Section 6.2 of NR

Package: sapa.
Source: basic-statistics.lisp.

Function: incomplete-gamma-q (a x) ¶

arguments:
a — parameter value > 0
x — variable >= 0
returns three values:
value of incomplete gamma function at a and x; the numerator (big gamma of a and x);
the denominator (gamma of a);
see Section 6.2 of NR

Package: sapa.
Source: basic-statistics.lisp.

Function: initial-estimates-for-zeros-of-polynomial (polynomial &key degree-of-polynomial initial-estimates scratch) ¶

Package: sapa.
Source: basic-math.lisp.

Function: kth-eigenvalue-of-tridiagonal-matrix (diag off-diag k &key squared-off-diag macheps) ¶

Package: sapa.
Source: multitaper.lisp.

Function: largest-eigenvalues-of-tridiagonal-matrix (diag off-diag number-of-tapers &key squared-off-diag macheps print-progress-p) ¶

Package: sapa.
Source: multitaper.lisp.

Function: one-iteration-of-two-step-burg (k step n fk bk phi limit) ¶

Package: sapa.
Source: parametric.lisp.

Function: power-of-2+1 (n) ¶

Package: sapa.
Source: utilities.lisp.

Function: pre-fft (n &key complex-exp-vector) ¶

Package: sapa.
Source: dft-and-fft.lisp.

Function: pre-fft-with-cache (n) ¶

Package: sapa.
Source: dft-and-fft.lisp.

Function: produce-upsilon-func (coefficients) ¶

Package: sapa.
Source: multitaper.lisp.

Function: series-representation-for-incomplete-gamma (a x) ¶

Package: sapa.
Source: basic-statistics.lisp.

Function: sturm-sequence-count (test-lambda diag off-diag squared-off-diag machep &key start end) ¶

Package: sapa.
Source: multitaper.lisp.

Function: symmetric-tridiagonal-infinity-norm (diag off-diag) ¶

Package: sapa.
Source: multitaper.lisp.

Function: symmetric-tridiagonal-solve! (diag off-diag b) ¶

given
[1] diag (required)
<=> diagonal part of symmetric tridiagonal matrix A; trash on output
[1] off-diag (required)
<=> off-diagonal part of symmetric tridiagonal matrix; trash on output
[2] b (required)
<=> on input, the right-hand side vector;
on output, the solution X to A X = b
returns
[4] X, the solution to A X = b, where X is the vector that contained b on input
—
Note: this is an implementation of Algorithm 4.3.6,
p. 156, Golub and Van Loan, 1989, with modifications
to avoid divides by zero

Package: sapa.
Source: multitaper.lisp.

Function: toeplitz (r y &optional x) ¶

given
[1] r (required)
==> vector of length 2*N-1 representing
the Toeplitz matrix R(i,j) with 0 <= i,j <= N-1, via the 2*N-1 values
r(0,N-1), r(0,N-2),..., r(0,1),
r(0,0), r(1,0),..., r(N-1,0)
[2] y (required)
==> right-hand side vector of length N
[3] x (optional; vector of same size as y)
<== solution vector of length N
solves the Toeplitz system sum_{j=0}^{N-1} r_{N-1+i-j} x_j = y_j for i = 0, 1, ..., N-1 and
returns
[1] x (a vector of length N)
or
nil (in case of a failure of the Levinson method
due to a singular principal minor
—
Note: this function is essentially a Lisp version
of the Fortran routine toeplz from Numerical Recipes

Package: sapa.
Source: multitaper.lisp.

Function: trapezoidal-rule (f a b s n) ¶

Package: sapa.
Source: basic-math.lisp.

Function: tridiag-eigenvalue->dpss! (eigenvalue order-of-taper diag off-diag &key eps maximum-number-of-iterations b) ¶

Package: sapa.
Source: multitaper.lisp.

Function: trig-prolate-sign-cosine-coefficients (m k) ¶

Package: sapa.
Source: multitaper.lisp.

Function: which-is-faster? (n-filter n-ts) ¶

Package: sapa.
Source: filtering.lisp.

Function: wosa-get-n-freqs (block-size oversampling-factor return-est-for-0-freq-p) ¶

Package: sapa.
Source: nonparametric.lisp.

Function: zeros-of-polynomial-with-initial-estimates (polynomial initial-estimates &key degree-of-polynomial scratch final-results maximum-number-of-iterations) ¶

Package: sapa.
Source: basic-math.lisp.

Previous: Definitions, Up: The sapaclisp Reference Manual [Contents][Index]

Appendix A Indexes

Concepts
Functions
Variables
Data types

Next: Functions, Previous: Indexes, Up: Indexes [Contents][Index]

A.1 Concepts

Next: Variables, Previous: Concepts, Up: Indexes [Contents][Index]

A.2 Functions

Jump to:	2 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

	Index Entry	Section

2
	`2d-matrix->linearized-upper-trangular`:	Public ordinary functions
	`2d-matrix-move!`:	Public ordinary functions

A
	`a*x`:	Public ordinary functions
	`a*x!`:	Public ordinary functions
	`a*x+b`:	Public ordinary functions
	`a*x+b!`:	Public ordinary functions
	`a*x+y`:	Public ordinary functions
	`a*x+y!`:	Public ordinary functions
	`absolute-sum-of-vector-elements`:	Private ordinary functions
	`acvs`:	Public ordinary functions
	`acvs-for-time-series-simulated-from-sdf`:	Public ordinary functions
	`add-sequences`:	Public ordinary functions
	`ar-coeffs->acvs`:	Public ordinary functions
	`ar-coeffs->prewhitening-filter`:	Public ordinary functions
	`ar-coeffs->reflection-coeffs`:	Public ordinary functions
	`ar-coeffs->sdf`:	Public ordinary functions
	`ar-coeffs->sdf-at-single-freq`:	Public ordinary functions
	`ar-coeffs->variance`:	Public ordinary functions
	`as-111`:	Private ordinary functions
	`as-91`:	Private ordinary functions
	`as-91-block-1`:	Private ordinary functions
	`as-91-block-4`:	Private ordinary functions

B
	`bandwidth&confidence-intervals-for-sdf-db`:	Public ordinary functions
	`bartlett-bandwidth->m`:	Public ordinary functions
	`bartlett-lag-window`:	Public ordinary functions
	`bartlett-m->bandwidth`:	Public ordinary functions
	`bartlett-n-m->degrees-of-freedom`:	Public ordinary functions
	`bessi0-nr`:	Private ordinary functions
	`biased-acvs->unbiased-acvs`:	Public ordinary functions
	`binary-search`:	Public ordinary functions
	`binary-search-internal`:	Private ordinary functions
	`bisection-with-newton-raphson`:	Public ordinary functions
	`box-plot`:	Public ordinary functions
	`burg-algorithm`:	Public ordinary functions

C
	`calculate-number-of-blocks`:	Private ordinary functions
	`careful-convert-to-db`:	Public ordinary functions
	`center&prewhiten&taper-time-series`:	Public ordinary functions
	`center&taper-time-series`:	Public ordinary functions
	`cepstrum->i_m`:	Public ordinary functions
	`check-orthonormality`:	Public ordinary functions
	`cholesky!`:	Public ordinary functions
	`circular-shift-sequence`:	Public ordinary functions
	`compare-seqs`:	Public ordinary functions
	`complex-of-absolutes`:	Private ordinary functions
	`compose-symmetric-filters`:	Public ordinary functions
	`continued-fraction-representation-for-incomplete-gamma`:	Private ordinary functions
	`convert-from-db`:	Public ordinary functions
	`convert-to-db`:	Public ordinary functions
	`copy-vector`:	Public ordinary functions
	`cosine-data-taper!`:	Public ordinary functions
	`create-ci-for-amt-sdf-estimate`:	Public ordinary functions
	`create-dpss-low-pass-filter`:	Public ordinary functions
	`create-least-squares-low-pass-filter`:	Public ordinary functions
	`cumulative-periodogram`:	Public ordinary functions
	`cumulative-sums`:	Public ordinary functions

D
	`daniell-bandwidth->m`:	Public ordinary functions
	`daniell-lag-window`:	Public ordinary functions
	`daniell-m->bandwidth`:	Public ordinary functions
	`daniell-n-m->degrees-of-freedom`:	Public ordinary functions
	`dft!`:	Public ordinary functions
	`dft-chirp!`:	Public ordinary functions
	`difference`:	Public ordinary functions
	`digamma`:	Public ordinary functions
	`direct-spectral-estimate`:	Public ordinary functions
	`divf`:	Public macros
	`dot-product`:	Public ordinary functions
	`dpss->eigenvalue`:	Private ordinary functions
	`dpss-data-taper!`:	Public ordinary functions
	`dpss-tapers-inverse-iteration`:	Public ordinary functions
	`dpss-tapers-thomson-approx`:	Public ordinary functions
	`dpss-tapers-tri-diag`:	Public ordinary functions
	`durbin-watson-test-statistic`:	Public ordinary functions

E
	`eigenspectra->adaptive-multitaper-spectral-estimate`:	Public ordinary functions
	`eigenspectra->multitaper-spectral-estimate`:	Public ordinary functions
	`eigenvalues-and-vectors-of-sym-tridiag-matrix`:	Private ordinary functions
	`equivalent-degrees-of-freedom`:	Public ordinary functions
	`equivalent-dof-for-wosa`:	Private ordinary functions
	`equivalent-dof-for-wosa-standard-case`:	Private ordinary functions
	`euclidean-norm`:	Public ordinary functions
	`eval-poly-2`:	Private ordinary functions
	`evaluate-polynomial`:	Public ordinary functions
	`exponential-smoothing`:	Public ordinary functions

F
	`factorial`:	Public ordinary functions
	`fast-forward-backward-ls`:	Public ordinary functions
	`fast-tridiag-eigenvalue->dpss!`:	Private ordinary functions
	`fft!`:	Public ordinary functions
	`filter-time-series`:	Public ordinary functions
	`filter-time-series-direct`:	Public ordinary functions
	`filter-time-series-fft`:	Public ordinary functions
	`find-peak-of-ar-sdf-using-quadratic-approx`:	Public ordinary functions
	`find-peak-or-valley-of-sdf-using-bisection+newton-raphson`:	Public ordinary functions
	`find-symmetric-frequency`:	Private ordinary functions
	`fisher-g-statistic`:	Public ordinary functions
	`flip-sign-of-coefficients!`:	Private ordinary functions
	`forward-backward-ls`:	Public ordinary functions
	`forward-ls`:	Public ordinary functions
	`Function, 2d-matrix->linearized-upper-trangular`:	Public ordinary functions
	`Function, 2d-matrix-move!`:	Public ordinary functions
	`Function, a*x`:	Public ordinary functions
	`Function, a*x!`:	Public ordinary functions
	`Function, a*x+b`:	Public ordinary functions
	`Function, a*x+b!`:	Public ordinary functions
	`Function, a*x+y`:	Public ordinary functions
	`Function, a*x+y!`:	Public ordinary functions
	`Function, absolute-sum-of-vector-elements`:	Private ordinary functions
	`Function, acvs`:	Public ordinary functions
	`Function, acvs-for-time-series-simulated-from-sdf`:	Public ordinary functions
	`Function, add-sequences`:	Public ordinary functions
	`Function, ar-coeffs->acvs`:	Public ordinary functions
	`Function, ar-coeffs->prewhitening-filter`:	Public ordinary functions
	`Function, ar-coeffs->reflection-coeffs`:	Public ordinary functions
	`Function, ar-coeffs->sdf`:	Public ordinary functions
	`Function, ar-coeffs->sdf-at-single-freq`:	Public ordinary functions
	`Function, ar-coeffs->variance`:	Public ordinary functions
	`Function, as-111`:	Private ordinary functions
	`Function, as-91`:	Private ordinary functions
	`Function, as-91-block-1`:	Private ordinary functions
	`Function, as-91-block-4`:	Private ordinary functions
	`Function, bandwidth&confidence-intervals-for-sdf-db`:	Public ordinary functions
	`Function, bartlett-bandwidth->m`:	Public ordinary functions
	`Function, bartlett-lag-window`:	Public ordinary functions
	`Function, bartlett-m->bandwidth`:	Public ordinary functions
	`Function, bartlett-n-m->degrees-of-freedom`:	Public ordinary functions
	`Function, bessi0-nr`:	Private ordinary functions
	`Function, biased-acvs->unbiased-acvs`:	Public ordinary functions
	`Function, binary-search`:	Public ordinary functions
	`Function, binary-search-internal`:	Private ordinary functions
	`Function, bisection-with-newton-raphson`:	Public ordinary functions
	`Function, box-plot`:	Public ordinary functions
	`Function, burg-algorithm`:	Public ordinary functions
	`Function, calculate-number-of-blocks`:	Private ordinary functions
	`Function, careful-convert-to-db`:	Public ordinary functions
	`Function, center&prewhiten&taper-time-series`:	Public ordinary functions
	`Function, center&taper-time-series`:	Public ordinary functions
	`Function, cepstrum->i_m`:	Public ordinary functions
	`Function, check-orthonormality`:	Public ordinary functions
	`Function, cholesky!`:	Public ordinary functions
	`Function, circular-shift-sequence`:	Public ordinary functions
	`Function, compare-seqs`:	Public ordinary functions
	`Function, complex-of-absolutes`:	Private ordinary functions
	`Function, compose-symmetric-filters`:	Public ordinary functions
	`Function, continued-fraction-representation-for-incomplete-gamma`:	Private ordinary functions
	`Function, convert-from-db`:	Public ordinary functions
	`Function, convert-to-db`:	Public ordinary functions
	`Function, copy-vector`:	Public ordinary functions
	`Function, cosine-data-taper!`:	Public ordinary functions
	`Function, create-ci-for-amt-sdf-estimate`:	Public ordinary functions
	`Function, create-dpss-low-pass-filter`:	Public ordinary functions
	`Function, create-least-squares-low-pass-filter`:	Public ordinary functions
	`Function, cumulative-periodogram`:	Public ordinary functions
	`Function, cumulative-sums`:	Public ordinary functions
	`Function, daniell-bandwidth->m`:	Public ordinary functions
	`Function, daniell-lag-window`:	Public ordinary functions
	`Function, daniell-m->bandwidth`:	Public ordinary functions
	`Function, daniell-n-m->degrees-of-freedom`:	Public ordinary functions
	`Function, dft!`:	Public ordinary functions
	`Function, dft-chirp!`:	Public ordinary functions
	`Function, difference`:	Public ordinary functions
	`Function, digamma`:	Public ordinary functions
	`Function, direct-spectral-estimate`:	Public ordinary functions
	`Function, dot-product`:	Public ordinary functions
	`Function, dpss->eigenvalue`:	Private ordinary functions
	`Function, dpss-data-taper!`:	Public ordinary functions
	`Function, dpss-tapers-inverse-iteration`:	Public ordinary functions
	`Function, dpss-tapers-thomson-approx`:	Public ordinary functions
	`Function, dpss-tapers-tri-diag`:	Public ordinary functions
	`Function, durbin-watson-test-statistic`:	Public ordinary functions
	`Function, eigenspectra->adaptive-multitaper-spectral-estimate`:	Public ordinary functions
	`Function, eigenspectra->multitaper-spectral-estimate`:	Public ordinary functions
	`Function, eigenvalues-and-vectors-of-sym-tridiag-matrix`:	Private ordinary functions
	`Function, equivalent-degrees-of-freedom`:	Public ordinary functions
	`Function, equivalent-dof-for-wosa`:	Private ordinary functions
	`Function, equivalent-dof-for-wosa-standard-case`:	Private ordinary functions
	`Function, euclidean-norm`:	Public ordinary functions
	`Function, eval-poly-2`:	Private ordinary functions
	`Function, evaluate-polynomial`:	Public ordinary functions
	`Function, exponential-smoothing`:	Public ordinary functions
	`Function, factorial`:	Public ordinary functions
	`Function, fast-forward-backward-ls`:	Public ordinary functions
	`Function, fast-tridiag-eigenvalue->dpss!`:	Private ordinary functions
	`Function, fft!`:	Public ordinary functions
	`Function, filter-time-series`:	Public ordinary functions
	`Function, filter-time-series-direct`:	Public ordinary functions
	`Function, filter-time-series-fft`:	Public ordinary functions
	`Function, find-peak-of-ar-sdf-using-quadratic-approx`:	Public ordinary functions
	`Function, find-peak-or-valley-of-sdf-using-bisection+newton-raphson`:	Public ordinary functions
	`Function, find-symmetric-frequency`:	Private ordinary functions
	`Function, fisher-g-statistic`:	Public ordinary functions
	`Function, flip-sign-of-coefficients!`:	Private ordinary functions
	`Function, forward-backward-ls`:	Public ordinary functions
	`Function, forward-ls`:	Public ordinary functions
	`Function, gauss-legendre-quadrature`:	Public ordinary functions
	`Function, generate-ar-time-series`:	Public ordinary functions
	`Function, generate-backward-innovations`:	Public ordinary functions
	`Function, generate-forward-innovations`:	Public ordinary functions
	`Function, generate-initial-guess-at-dpss`:	Private ordinary functions
	`Function, generate-ma-time-series`:	Public ordinary functions
	`Function, generate-tri-prolate-taper`:	Private ordinary functions
	`Function, generate-white-noise`:	Public ordinary functions
	`Function, get-n-dft`:	Private ordinary functions
	`Function, get-n-freqs`:	Private ordinary functions
	`Function, get-offset-to-kth-block`:	Private ordinary functions
	`Function, grenander-smoothing-window-bandwidth`:	Public ordinary functions
	`Function, h-func`:	Private ordinary functions
	`Function, hanning-data-taper!`:	Public ordinary functions
	`Function, hermitian-transpose`:	Public ordinary functions
	`Function, histogram`:	Public ordinary functions
	`Function, householder-reduction-of-real-sym-matrix!`:	Private ordinary functions
	`Function, huber-weight-function`:	Public ordinary functions
	`Function, ideal-band-pass-filter-irs`:	Public ordinary functions
	`Function, ideal-high-pass-filter-irs`:	Public ordinary functions
	`Function, ideal-low-pass-filter-irs`:	Public ordinary functions
	`Function, incomplete-gamma`:	Private ordinary functions
	`Function, incomplete-gamma-q`:	Private ordinary functions
	`Function, initial-estimates-for-zeros-of-polynomial`:	Private ordinary functions
	`Function, integrate-sdf`:	Public ordinary functions
	`Function, interquartile-range`:	Public ordinary functions
	`Function, inverse-dft!`:	Public ordinary functions
	`Function, inverse-fft!`:	Public ordinary functions
	`Function, iota`:	Public ordinary functions
	`Function, jenkins-smoothing-window-bandwidth`:	Public ordinary functions
	`Function, kernel-pdf-estimation`:	Public ordinary functions
	`Function, kth-eigenvalue-of-tridiagonal-matrix`:	Private ordinary functions
	`Function, lag-window-spectral-estimate`:	Public ordinary functions
	`Function, largest-eigenvalues-of-tridiagonal-matrix`:	Private ordinary functions
	`Function, linear-interpolation!`:	Public ordinary functions
	`Function, linearized-upper-trangular->2d-matrix`:	Public ordinary functions
	`Function, log-of-gamma`:	Public ordinary functions
	`Function, log10`:	Public ordinary functions
	`Function, lower-triangular-solve!`:	Public ordinary functions
	`Function, m-location-estimate`:	Public ordinary functions
	`Function, max-of-seq`:	Public ordinary functions
	`Function, median-absolute-deviation`:	Public ordinary functions
	`Function, min-and-max-of-seq`:	Public ordinary functions
	`Function, min-of-seq`:	Public ordinary functions
	`Function, modified-gram-schmidt!`:	Public ordinary functions
	`Function, multiply-2-polynomials`:	Public ordinary functions
	`Function, multiply-matrix-and-scalar`:	Public ordinary functions
	`Function, multiply-matrix-and-vector`:	Public ordinary functions
	`Function, multiply-polynomials`:	Public ordinary functions
	`Function, multiply-sequences`:	Public ordinary functions
	`Function, multiply-two-matrices`:	Public ordinary functions
	`Function, multitaper-spectral-estimate`:	Public ordinary functions
	`Function, n-applications-of-three-point-smoother`:	Public ordinary functions
	`Function, newton-raphson`:	Public ordinary functions
	`Function, next-power-of-2`:	Public ordinary functions
	`Function, nyquist-frequency->sampling-time`:	Public ordinary functions
	`Function, one-iteration-of-two-step-burg`:	Private ordinary functions
	`Function, one-sided-freq->two-sided-freq`:	Public ordinary functions
	`Function, one-sided-sdf->two-sided-sdf`:	Public ordinary functions
	`Function, ordinary-least-squares-cholesky`:	Public ordinary functions
	`Function, ordinary-least-squares-q-r`:	Public ordinary functions
	`Function, papoulis-bandwidth->m`:	Public ordinary functions
	`Function, papoulis-lag-window`:	Public ordinary functions
	`Function, papoulis-m->bandwidth`:	Public ordinary functions
	`Function, papoulis-n-m->degrees-of-freedom`:	Public ordinary functions
	`Function, parzen-bandwidth->m`:	Public ordinary functions
	`Function, parzen-lag-window`:	Public ordinary functions
	`Function, parzen-m->bandwidth`:	Public ordinary functions
	`Function, parzen-n-m->degrees-of-freedom`:	Public ordinary functions
	`Function, periodogram`:	Public ordinary functions
	`Function, periodogram-at-one-frequency`:	Public ordinary functions
	`Function, postcolor-spectral-estimate`:	Public ordinary functions
	`Function, power-of-2`:	Public ordinary functions
	`Function, power-of-2+1`:	Private ordinary functions
	`Function, pre-fft`:	Private ordinary functions
	`Function, pre-fft-with-cache`:	Private ordinary functions
	`Function, predicted-y-at-x`:	Public ordinary functions
	`Function, print-1-or-2-d-array`:	Public ordinary functions
	`Function, print-rows-of-nxm-matrix`:	Public ordinary functions
	`Function, produce-upsilon-func`:	Private ordinary functions
	`Function, q-q-plot`:	Public ordinary functions
	`Function, q-r!`:	Public ordinary functions
	`Function, quantile-of-chi-square-2-distribution`:	Public ordinary functions
	`Function, quantile-of-chi-square-distribution`:	Public ordinary functions
	`Function, quantile-of-exponential-distribution`:	Public ordinary functions
	`Function, quantile-of-gamma-distribution`:	Public ordinary functions
	`Function, quantile-of-kolmogorov-test-statistic`:	Public ordinary functions
	`Function, quantile-of-normal-distribution`:	Public ordinary functions
	`Function, quantile-of-ordered-seq`:	Public ordinary functions
	`Function, quantile-plot`:	Public ordinary functions
	`Function, ranorm`:	Public ordinary functions
	`Function, ranorms`:	Public ordinary functions
	`Function, reflection-coeffs->ar-coeffs`:	Public ordinary functions
	`Function, reflection-coeffs->variance`:	Public ordinary functions
	`Function, regression-with-ar-errors`:	Public ordinary functions
	`Function, running-median`:	Public ordinary functions
	`Function, sample-cepstrum`:	Public ordinary functions
	`Function, sample-correlation-coefficient`:	Public ordinary functions
	`Function, sample-from-a-function`:	Public ordinary functions
	`Function, sample-mean`:	Public ordinary functions
	`Function, sample-mean-and-variance`:	Public ordinary functions
	`Function, sample-median`:	Public ordinary functions
	`Function, sample-skewness-and-kurtosis`:	Public ordinary functions
	`Function, sample-variance`:	Public ordinary functions
	`Function, sample-variogram`:	Public ordinary functions
	`Function, sampling-time->nyquist-frequency`:	Public ordinary functions
	`Function, sdf->sdf-with-accurate-peaks`:	Public ordinary functions
	`Function, secant-method`:	Public ordinary functions
	`Function, series-representation-for-incomplete-gamma`:	Private ordinary functions
	`Function, sign`:	Public ordinary functions
	`Function, simple-numerical-integration`:	Public ordinary functions
	`Function, simulate-time-series-from-sdf`:	Public ordinary functions
	`Function, smoothing-window-for-lag-window-spectral-estimate`:	Public ordinary functions
	`Function, spectral-window-for-direct-spectral-estimate`:	Public ordinary functions
	`Function, spectral-window-for-lag-window-spectral-estimate`:	Public ordinary functions
	`Function, spofa!`:	Public ordinary functions
	`Function, sposl!`:	Public ordinary functions
	`Function, standard-normal-pdf`:	Public ordinary functions
	`Function, step-down-levinson-durbin-recursions`:	Public ordinary functions
	`Function, sturm-sequence-count`:	Private ordinary functions
	`Function, subtract-two-matrices`:	Public ordinary functions
	`Function, sum`:	Public ordinary functions
	`Function, sum-of-squares`:	Public ordinary functions
	`Function, supplied-data-taper!`:	Public ordinary functions
	`Function, symmetric-tridiagonal-infinity-norm`:	Private ordinary functions
	`Function, symmetric-tridiagonal-solve!`:	Private ordinary functions
	`Function, symmetry-plot`:	Public ordinary functions
	`Function, tail-area-of-normal-distribution`:	Public ordinary functions
	`Function, thomson-weight-function`:	Public ordinary functions
	`Function, three-point-smoother`:	Public ordinary functions
	`Function, time-series-bandwidth`:	Public ordinary functions
	`Function, toeplitz`:	Private ordinary functions
	`Function, trace-matrix`:	Public ordinary functions
	`Function, transfer-function-for-filter`:	Public ordinary functions
	`Function, transform-a-sequence`:	Public ordinary functions
	`Function, transform-a-sequence!`:	Public ordinary functions
	`Function, transpose`:	Public ordinary functions
	`Function, trapezoidal-rule`:	Private ordinary functions
	`Function, triangular-convergence-factors`:	Public ordinary functions
	`Function, tridiag-eigenvalue->dpss!`:	Private ordinary functions
	`Function, trig-prolate-sign-cosine-coefficients`:	Private ordinary functions
	`Function, trig-prolate-tapers`:	Public ordinary functions
	`Function, trigamma`:	Public ordinary functions
	`Function, two-step-burg-algorithm`:	Public ordinary functions
	`Function, upper-triangular-solve!`:	Public ordinary functions
	`Function, var-predicted-mean-at-x`:	Public ordinary functions
	`Function, var-predicted-y-at-x`:	Public ordinary functions
	`Function, weighted-linear-least-squares`:	Public ordinary functions
	`Function, weighted-mean`:	Public ordinary functions
	`Function, which-is-faster?`:	Private ordinary functions
	`Function, window-width-from-silverman`:	Public ordinary functions
	`Function, wosa-get-n-freqs`:	Private ordinary functions
	`Function, wosa-spectral-estimate`:	Public ordinary functions
	`Function, x*y`:	Public ordinary functions
	`Function, x*y!`:	Public ordinary functions
	`Function, x+b`:	Public ordinary functions
	`Function, x+b!`:	Public ordinary functions
	`Function, x+y`:	Public ordinary functions
	`Function, x+y!`:	Public ordinary functions
	`Function, x-y`:	Public ordinary functions
	`Function, x-y!`:	Public ordinary functions
	`Function, yule-walker-algorithm-given-acvs`:	Public ordinary functions
	`Function, yule-walker-algorithm-given-data`:	Public ordinary functions
	`Function, zero-strict-lower-diagonal!`:	Public ordinary functions
	`Function, zeros-of-polynomial`:	Public ordinary functions
	`Function, zeros-of-polynomial-with-initial-estimates`:	Private ordinary functions

G
	`gauss-legendre-quadrature`:	Public ordinary functions
	`generate-ar-time-series`:	Public ordinary functions
	`generate-backward-innovations`:	Public ordinary functions
	`generate-forward-innovations`:	Public ordinary functions
	`generate-initial-guess-at-dpss`:	Private ordinary functions
	`generate-ma-time-series`:	Public ordinary functions
	`generate-tri-prolate-taper`:	Private ordinary functions
	`generate-white-noise`:	Public ordinary functions
	`get-n-dft`:	Private ordinary functions
	`get-n-freqs`:	Private ordinary functions
	`get-offset-to-kth-block`:	Private ordinary functions
	`grenander-smoothing-window-bandwidth`:	Public ordinary functions

H
	`h-func`:	Private ordinary functions
	`hanning-data-taper!`:	Public ordinary functions
	`hermitian-transpose`:	Public ordinary functions
	`histogram`:	Public ordinary functions
	`householder-reduction-of-real-sym-matrix!`:	Private ordinary functions
	`huber-weight-function`:	Public ordinary functions

I
	`ideal-band-pass-filter-irs`:	Public ordinary functions
	`ideal-high-pass-filter-irs`:	Public ordinary functions
	`ideal-low-pass-filter-irs`:	Public ordinary functions
	`incomplete-gamma`:	Private ordinary functions
	`incomplete-gamma-q`:	Private ordinary functions
	`initial-estimates-for-zeros-of-polynomial`:	Private ordinary functions
	`integrate-sdf`:	Public ordinary functions
	`interquartile-range`:	Public ordinary functions
	`inverse-dft!`:	Public ordinary functions
	`inverse-fft!`:	Public ordinary functions
	`iota`:	Public ordinary functions

J
	`jenkins-smoothing-window-bandwidth`:	Public ordinary functions

K
	`kernel-pdf-estimation`:	Public ordinary functions
	`kth-eigenvalue-of-tridiagonal-matrix`:	Private ordinary functions

L
	`lag-window-spectral-estimate`:	Public ordinary functions
	`largest-eigenvalues-of-tridiagonal-matrix`:	Private ordinary functions
	`linear-interpolation!`:	Public ordinary functions
	`linearized-upper-trangular->2d-matrix`:	Public ordinary functions
	`log-of-gamma`:	Public ordinary functions
	`log10`:	Public ordinary functions
	`lower-triangular-solve!`:	Public ordinary functions

M
	`m-location-estimate`:	Public ordinary functions
	`Macro, divf`:	Public macros
	`Macro, multf`:	Public macros
	`max-of-seq`:	Public ordinary functions
	`median-absolute-deviation`:	Public ordinary functions
	`min-and-max-of-seq`:	Public ordinary functions
	`min-of-seq`:	Public ordinary functions
	`modified-gram-schmidt!`:	Public ordinary functions
	`multf`:	Public macros
	`multiply-2-polynomials`:	Public ordinary functions
	`multiply-matrix-and-scalar`:	Public ordinary functions
	`multiply-matrix-and-vector`:	Public ordinary functions
	`multiply-polynomials`:	Public ordinary functions
	`multiply-sequences`:	Public ordinary functions
	`multiply-two-matrices`:	Public ordinary functions
	`multitaper-spectral-estimate`:	Public ordinary functions

N
	`n-applications-of-three-point-smoother`:	Public ordinary functions
	`newton-raphson`:	Public ordinary functions
	`next-power-of-2`:	Public ordinary functions
	`nyquist-frequency->sampling-time`:	Public ordinary functions

O
	`one-iteration-of-two-step-burg`:	Private ordinary functions
	`one-sided-freq->two-sided-freq`:	Public ordinary functions
	`one-sided-sdf->two-sided-sdf`:	Public ordinary functions
	`ordinary-least-squares-cholesky`:	Public ordinary functions
	`ordinary-least-squares-q-r`:	Public ordinary functions

P
	`papoulis-bandwidth->m`:	Public ordinary functions
	`papoulis-lag-window`:	Public ordinary functions
	`papoulis-m->bandwidth`:	Public ordinary functions
	`papoulis-n-m->degrees-of-freedom`:	Public ordinary functions
	`parzen-bandwidth->m`:	Public ordinary functions
	`parzen-lag-window`:	Public ordinary functions
	`parzen-m->bandwidth`:	Public ordinary functions
	`parzen-n-m->degrees-of-freedom`:	Public ordinary functions
	`periodogram`:	Public ordinary functions
	`periodogram-at-one-frequency`:	Public ordinary functions
	`postcolor-spectral-estimate`:	Public ordinary functions
	`power-of-2`:	Public ordinary functions
	`power-of-2+1`:	Private ordinary functions
	`pre-fft`:	Private ordinary functions
	`pre-fft-with-cache`:	Private ordinary functions
	`predicted-y-at-x`:	Public ordinary functions
	`print-1-or-2-d-array`:	Public ordinary functions
	`print-rows-of-nxm-matrix`:	Public ordinary functions
	`produce-upsilon-func`:	Private ordinary functions

Q
	`q-q-plot`:	Public ordinary functions
	`q-r!`:	Public ordinary functions
	`quantile-of-chi-square-2-distribution`:	Public ordinary functions
	`quantile-of-chi-square-distribution`:	Public ordinary functions
	`quantile-of-exponential-distribution`:	Public ordinary functions
	`quantile-of-gamma-distribution`:	Public ordinary functions
	`quantile-of-kolmogorov-test-statistic`:	Public ordinary functions
	`quantile-of-normal-distribution`:	Public ordinary functions
	`quantile-of-ordered-seq`:	Public ordinary functions
	`quantile-plot`:	Public ordinary functions

R
	`ranorm`:	Public ordinary functions
	`ranorms`:	Public ordinary functions
	`reflection-coeffs->ar-coeffs`:	Public ordinary functions
	`reflection-coeffs->variance`:	Public ordinary functions
	`regression-with-ar-errors`:	Public ordinary functions
	`running-median`:	Public ordinary functions

S
	`sample-cepstrum`:	Public ordinary functions
	`sample-correlation-coefficient`:	Public ordinary functions
	`sample-from-a-function`:	Public ordinary functions
	`sample-mean`:	Public ordinary functions
	`sample-mean-and-variance`:	Public ordinary functions
	`sample-median`:	Public ordinary functions
	`sample-skewness-and-kurtosis`:	Public ordinary functions
	`sample-variance`:	Public ordinary functions
	`sample-variogram`:	Public ordinary functions
	`sampling-time->nyquist-frequency`:	Public ordinary functions
	`sdf->sdf-with-accurate-peaks`:	Public ordinary functions
	`secant-method`:	Public ordinary functions
	`series-representation-for-incomplete-gamma`:	Private ordinary functions
	`sign`:	Public ordinary functions
	`simple-numerical-integration`:	Public ordinary functions
	`simulate-time-series-from-sdf`:	Public ordinary functions
	`smoothing-window-for-lag-window-spectral-estimate`:	Public ordinary functions
	`spectral-window-for-direct-spectral-estimate`:	Public ordinary functions
	`spectral-window-for-lag-window-spectral-estimate`:	Public ordinary functions
	`spofa!`:	Public ordinary functions
	`sposl!`:	Public ordinary functions
	`standard-normal-pdf`:	Public ordinary functions
	`step-down-levinson-durbin-recursions`:	Public ordinary functions
	`sturm-sequence-count`:	Private ordinary functions
	`subtract-two-matrices`:	Public ordinary functions
	`sum`:	Public ordinary functions
	`sum-of-squares`:	Public ordinary functions
	`supplied-data-taper!`:	Public ordinary functions
	`symmetric-tridiagonal-infinity-norm`:	Private ordinary functions
	`symmetric-tridiagonal-solve!`:	Private ordinary functions
	`symmetry-plot`:	Public ordinary functions

T
	`tail-area-of-normal-distribution`:	Public ordinary functions
	`thomson-weight-function`:	Public ordinary functions
	`three-point-smoother`:	Public ordinary functions
	`time-series-bandwidth`:	Public ordinary functions
	`toeplitz`:	Private ordinary functions
	`trace-matrix`:	Public ordinary functions
	`transfer-function-for-filter`:	Public ordinary functions
	`transform-a-sequence`:	Public ordinary functions
	`transform-a-sequence!`:	Public ordinary functions
	`transpose`:	Public ordinary functions
	`trapezoidal-rule`:	Private ordinary functions
	`triangular-convergence-factors`:	Public ordinary functions
	`tridiag-eigenvalue->dpss!`:	Private ordinary functions
	`trig-prolate-sign-cosine-coefficients`:	Private ordinary functions
	`trig-prolate-tapers`:	Public ordinary functions
	`trigamma`:	Public ordinary functions
	`two-step-burg-algorithm`:	Public ordinary functions

U
	`upper-triangular-solve!`:	Public ordinary functions

V
	`var-predicted-mean-at-x`:	Public ordinary functions
	`var-predicted-y-at-x`:	Public ordinary functions

W
	`weighted-linear-least-squares`:	Public ordinary functions
	`weighted-mean`:	Public ordinary functions
	`which-is-faster?`:	Private ordinary functions
	`window-width-from-silverman`:	Public ordinary functions
	`wosa-get-n-freqs`:	Private ordinary functions
	`wosa-spectral-estimate`:	Public ordinary functions

X
	`x*y`:	Public ordinary functions
	`x*y!`:	Public ordinary functions
	`x+b`:	Public ordinary functions
	`x+b!`:	Public ordinary functions
	`x+y`:	Public ordinary functions
	`x+y!`:	Public ordinary functions
	`x-y`:	Public ordinary functions
	`x-y!`:	Public ordinary functions

Y
	`yule-walker-algorithm-given-acvs`:	Public ordinary functions
	`yule-walker-algorithm-given-data`:	Public ordinary functions

Z
	`zero-strict-lower-diagonal!`:	Public ordinary functions
	`zeros-of-polynomial`:	Public ordinary functions
	`zeros-of-polynomial-with-initial-estimates`:	Private ordinary functions

Jump to:	2 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]

A.3 Variables

Jump to:	* + C S

	Index Entry	Section

*
	`abscissas-32-point`:	Private special variables
	`sapa-cached-pre-fft-arrays`:	Private special variables
	`weights-32-point`:	Private special variables

+
	`+coefficents-for-log-of-gamma+`:	Private special variables
	`+euler-constant+`:	Private constants
	`+log-pi+`:	Private constants
	`+nr-gser-eps+`:	Private special variables
	`+nr-gser-itmax+`:	Private special variables
	`+ppchi2-aa+`:	Private constants
	`+ppchi2-c1+`:	Private constants
	`+ppchi2-c10+`:	Private constants
	`+ppchi2-c11+`:	Private constants
	`+ppchi2-c12+`:	Private constants
	`+ppchi2-c13+`:	Private constants
	`+ppchi2-c14+`:	Private constants
	`+ppchi2-c15+`:	Private constants
	`+ppchi2-c16+`:	Private constants
	`+ppchi2-c17+`:	Private constants
	`+ppchi2-c18+`:	Private constants
	`+ppchi2-c19+`:	Private constants
	`+ppchi2-c2+`:	Private constants
	`+ppchi2-c20+`:	Private constants
	`+ppchi2-c21+`:	Private constants
	`+ppchi2-c22+`:	Private constants
	`+ppchi2-c23+`:	Private constants
	`+ppchi2-c24+`:	Private constants
	`+ppchi2-c25+`:	Private constants
	`+ppchi2-c26+`:	Private constants
	`+ppchi2-c27+`:	Private constants
	`+ppchi2-c28+`:	Private constants
	`+ppchi2-c29+`:	Private constants
	`+ppchi2-c3+`:	Private constants
	`+ppchi2-c30+`:	Private constants
	`+ppchi2-c31+`:	Private constants
	`+ppchi2-c32+`:	Private constants
	`+ppchi2-c33+`:	Private constants
	`+ppchi2-c34+`:	Private constants
	`+ppchi2-c35+`:	Private constants
	`+ppchi2-c36+`:	Private constants
	`+ppchi2-c37+`:	Private constants
	`+ppchi2-c38+`:	Private constants
	`+ppchi2-c4+`:	Private constants
	`+ppchi2-c5+`:	Private constants
	`+ppchi2-c6+`:	Private constants
	`+ppchi2-c7+`:	Private constants
	`+ppchi2-c8+`:	Private constants
	`+ppchi2-c9+`:	Private constants
	`+ppchi2-e+`:	Private constants
	`+ppchi2-pmax+`:	Private constants
	`+ppchi2-pmin+`:	Private constants
	`+ppnd-a0+`:	Private constants
	`+ppnd-a1+`:	Private constants
	`+ppnd-a2+`:	Private constants
	`+ppnd-a3+`:	Private constants
	`+ppnd-b1+`:	Private constants
	`+ppnd-b2+`:	Private constants
	`+ppnd-b3+`:	Private constants
	`+ppnd-b4+`:	Private constants
	`+ppnd-c0+`:	Private constants
	`+ppnd-c1+`:	Private constants
	`+ppnd-c2+`:	Private constants
	`+ppnd-c3+`:	Private constants
	`+ppnd-d1+`:	Private constants
	`+ppnd-d2+`:	Private constants
	`+sapa-10-over-log-10+`:	Private constants
	`+sapa-2-pi+`:	Private constants
	`+sapa-4-time-exp-of-1-over-4+`:	Private constants
	`+sapa-4-time-exp-of-minus-1-point-35+`:	Private constants
	`+sapa-minus-2-pi+`:	Private constants
	`+sapa-sqrt-8-over-e+`:	Private constants
	`+sqrt-of-two-pi+`:	Private constants
	`+use-pre-fft-with-cache-p+`:	Private special variables

C
	`Constant, +euler-constant+`:	Private constants
	`Constant, +log-pi+`:	Private constants
	`Constant, +ppchi2-aa+`:	Private constants
	`Constant, +ppchi2-c1+`:	Private constants
	`Constant, +ppchi2-c10+`:	Private constants
	`Constant, +ppchi2-c11+`:	Private constants
	`Constant, +ppchi2-c12+`:	Private constants
	`Constant, +ppchi2-c13+`:	Private constants
	`Constant, +ppchi2-c14+`:	Private constants
	`Constant, +ppchi2-c15+`:	Private constants
	`Constant, +ppchi2-c16+`:	Private constants
	`Constant, +ppchi2-c17+`:	Private constants
	`Constant, +ppchi2-c18+`:	Private constants
	`Constant, +ppchi2-c19+`:	Private constants
	`Constant, +ppchi2-c2+`:	Private constants
	`Constant, +ppchi2-c20+`:	Private constants
	`Constant, +ppchi2-c21+`:	Private constants
	`Constant, +ppchi2-c22+`:	Private constants
	`Constant, +ppchi2-c23+`:	Private constants
	`Constant, +ppchi2-c24+`:	Private constants
	`Constant, +ppchi2-c25+`:	Private constants
	`Constant, +ppchi2-c26+`:	Private constants
	`Constant, +ppchi2-c27+`:	Private constants
	`Constant, +ppchi2-c28+`:	Private constants
	`Constant, +ppchi2-c29+`:	Private constants
	`Constant, +ppchi2-c3+`:	Private constants
	`Constant, +ppchi2-c30+`:	Private constants
	`Constant, +ppchi2-c31+`:	Private constants
	`Constant, +ppchi2-c32+`:	Private constants
	`Constant, +ppchi2-c33+`:	Private constants
	`Constant, +ppchi2-c34+`:	Private constants
	`Constant, +ppchi2-c35+`:	Private constants
	`Constant, +ppchi2-c36+`:	Private constants
	`Constant, +ppchi2-c37+`:	Private constants
	`Constant, +ppchi2-c38+`:	Private constants
	`Constant, +ppchi2-c4+`:	Private constants
	`Constant, +ppchi2-c5+`:	Private constants
	`Constant, +ppchi2-c6+`:	Private constants
	`Constant, +ppchi2-c7+`:	Private constants
	`Constant, +ppchi2-c8+`:	Private constants
	`Constant, +ppchi2-c9+`:	Private constants
	`Constant, +ppchi2-e+`:	Private constants
	`Constant, +ppchi2-pmax+`:	Private constants
	`Constant, +ppchi2-pmin+`:	Private constants
	`Constant, +ppnd-a0+`:	Private constants
	`Constant, +ppnd-a1+`:	Private constants
	`Constant, +ppnd-a2+`:	Private constants
	`Constant, +ppnd-a3+`:	Private constants
	`Constant, +ppnd-b1+`:	Private constants
	`Constant, +ppnd-b2+`:	Private constants
	`Constant, +ppnd-b3+`:	Private constants
	`Constant, +ppnd-b4+`:	Private constants
	`Constant, +ppnd-c0+`:	Private constants
	`Constant, +ppnd-c1+`:	Private constants
	`Constant, +ppnd-c2+`:	Private constants
	`Constant, +ppnd-c3+`:	Private constants
	`Constant, +ppnd-d1+`:	Private constants
	`Constant, +ppnd-d2+`:	Private constants
	`Constant, +sapa-10-over-log-10+`:	Private constants
	`Constant, +sapa-2-pi+`:	Private constants
	`Constant, +sapa-4-time-exp-of-1-over-4+`:	Private constants
	`Constant, +sapa-4-time-exp-of-minus-1-point-35+`:	Private constants
	`Constant, +sapa-minus-2-pi+`:	Private constants
	`Constant, +sapa-sqrt-8-over-e+`:	Private constants
	`Constant, +sqrt-of-two-pi+`:	Private constants

S
	`Special Variable, abscissas-32-point`:	Private special variables
	`Special Variable, sapa-cached-pre-fft-arrays`:	Private special variables
	`Special Variable, weights-32-point`:	Private special variables
	`Special Variable, +coefficents-for-log-of-gamma+`:	Private special variables
	`Special Variable, +nr-gser-eps+`:	Private special variables
	`Special Variable, +nr-gser-itmax+`:	Private special variables
	`Special Variable, +use-pre-fft-with-cache-p+`:	Private special variables

Previous: Variables, Up: Indexes [Contents][Index]

A.4 Data types

Jump to:	A B D F H M N P R S T U

	Index Entry	Section

A
	`acvs.lisp`:	The sapaclisp/acvs․lisp file

B
	`basic-math.lisp`:	The sapaclisp/basic-math․lisp file
	`basic-statistics.lisp`:	The sapaclisp/basic-statistics․lisp file

D
	`dft-and-fft.lisp`:	The sapaclisp/dft-and-fft․lisp file

F
	`File, acvs.lisp`:	The sapaclisp/acvs․lisp file
	`File, basic-math.lisp`:	The sapaclisp/basic-math․lisp file
	`File, basic-statistics.lisp`:	The sapaclisp/basic-statistics․lisp file
	`File, dft-and-fft.lisp`:	The sapaclisp/dft-and-fft․lisp file
	`File, filtering.lisp`:	The sapaclisp/filtering․lisp file
	`File, hacks.lisp`:	The sapaclisp/hacks․lisp file
	`File, harmonic.lisp`:	The sapaclisp/harmonic․lisp file
	`File, matrix.lisp`:	The sapaclisp/matrix․lisp file
	`File, multitaper.lisp`:	The sapaclisp/multitaper․lisp file
	`File, nonparametric.lisp`:	The sapaclisp/nonparametric․lisp file
	`File, parametric.lisp`:	The sapaclisp/parametric․lisp file
	`File, random.lisp`:	The sapaclisp/random․lisp file
	`File, sapa-package.lisp`:	The sapaclisp/sapa-package․lisp file
	`File, sapaclisp.asd`:	The sapaclisp/sapaclisp․asd file
	`File, tapers.lisp`:	The sapaclisp/tapers․lisp file
	`File, utilities.lisp`:	The sapaclisp/utilities․lisp file
	`filtering.lisp`:	The sapaclisp/filtering․lisp file

H
	`hacks.lisp`:	The sapaclisp/hacks․lisp file
	`harmonic.lisp`:	The sapaclisp/harmonic․lisp file

M
	`matrix.lisp`:	The sapaclisp/matrix․lisp file
	`multitaper.lisp`:	The sapaclisp/multitaper․lisp file

N
	`nonparametric.lisp`:	The sapaclisp/nonparametric․lisp file

P
	`Package, sapa`:	The sapa package
	`Package, sapaclisp-asd`:	The sapaclisp-asd package
	`parametric.lisp`:	The sapaclisp/parametric․lisp file

R
	`random.lisp`:	The sapaclisp/random․lisp file

S
	`sapa`:	The sapa package
	`sapa-package.lisp`:	The sapaclisp/sapa-package․lisp file
	`sapaclisp`:	The sapaclisp system
	`sapaclisp-asd`:	The sapaclisp-asd package
	`sapaclisp.asd`:	The sapaclisp/sapaclisp․asd file
	`System, sapaclisp`:	The sapaclisp system

T
	`tapers.lisp`:	The sapaclisp/tapers․lisp file

U
	`utilities.lisp`:	The sapaclisp/utilities․lisp file

The sapaclisp Reference Manual

Table of Contents

1 Systems

1.1 sapaclisp

2 Files

2.1 Lisp

2.1.1 sapaclisp/sapaclisp.asd

2.1.2 sapaclisp/sapa-package.lisp

2.1.3 sapaclisp/hacks.lisp

2.1.4 sapaclisp/utilities.lisp

2.1.5 sapaclisp/matrix.lisp

2.1.6 sapaclisp/basic-math.lisp

2.1.7 sapaclisp/dft-and-fft.lisp

2.1.8 sapaclisp/basic-statistics.lisp

2.1.9 sapaclisp/random.lisp

2.1.10 sapaclisp/tapers.lisp

2.1.11 sapaclisp/filtering.lisp

2.1.12 sapaclisp/acvs.lisp

2.1.13 sapaclisp/parametric.lisp

2.1.14 sapaclisp/multitaper.lisp

2.1.15 sapaclisp/nonparametric.lisp

2.1.16 sapaclisp/harmonic.lisp

3 Packages

3.1 sapaclisp-asd

3.2 sapa

4 Definitions

4.1 Public Interface

4.1.1 Macros

4.1.2 Ordinary functions

4.2 Internals

4.2.1 Constants

4.2.2 Special variables

4.2.3 Ordinary functions

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types

1.1 `sapaclisp`

2.1.1 `sapaclisp/sapaclisp.asd`

2.1.2 `sapaclisp/sapa-package.lisp`

2.1.3 `sapaclisp/hacks.lisp`

2.1.4 `sapaclisp/utilities.lisp`

2.1.5 `sapaclisp/matrix.lisp`

2.1.6 `sapaclisp/basic-math.lisp`

2.1.7 `sapaclisp/dft-and-fft.lisp`

2.1.8 `sapaclisp/basic-statistics.lisp`

2.1.9 `sapaclisp/random.lisp`

2.1.10 `sapaclisp/tapers.lisp`

2.1.11 `sapaclisp/filtering.lisp`

2.1.12 `sapaclisp/acvs.lisp`

2.1.13 `sapaclisp/parametric.lisp`

2.1.14 `sapaclisp/multitaper.lisp`

2.1.15 `sapaclisp/nonparametric.lisp`

2.1.16 `sapaclisp/harmonic.lisp`

3.1 `sapaclisp-asd`

3.2 `sapa`