\documentstyle[11pt]{article}
\setlength{\oddsidemargin}{.125in}
\setlength{\textwidth}{6.25in}
\setlength{\textheight}{8.25in}
\setlength{\topmargin}{0in}
\renewcommand{\baselinestretch}{1.15}
\setlength{\parskip}{1ex}
\setlength{\itemsep}{1ex}
\setlength{\parindent}{5ex}
\hyphenation{Add-Data-Type data-type Data-Type Get-All-Factors
Inv-DFTransform Inv-Z-Transform LMultiD-ROC Z-Transform}
\setcounter{page}{1}
\begin{document}
\begin{center}
{\bf
SUMMARY OF SIGNAL PROCESSING OBJECTS
}
\end{center}
\begin{enumerate}
\item {\tt ASPAnalyze} (in ``ASPAnalyze.m'') \newline
ASPAnalyze[f, t] and ASPAnalyze[f, t, start, end]
will plot f(t) as a one-dimensional, continuous-time function
(real part shown as solid lines, imaginary part as dashed lines).
It will also print the strip of convergence, indicate stability
criteria, display the pole-zero diagram, and plot the magnitude
and phase responses. For the two-dimensional version, t is a
list of two variables (like \{t1, t2\}) and start/end are optional
two-element lists specifying the range of the time-domain plot.
All non-variable symbols will be assigned a value of 1 when the
analyzer needs to generate a plot (override this by using options
like a -$>$ 2).
\item {\tt AddChildToTree} (in ``Tree.m'') \newline
AddChildToTree[tree, parent, newchild] adds newchild under
every parent in tree.
\item {\tt AddDataType} (in ``DataType.m'') \newline
AddDataType[data type], AddDataType[data type, parent data type],
and AddDataType[data type, parent data type, Fourier data type]
will update the tree data type structure to include the
new data type and its corresponding Fourier domain
data type (which defaults to Complex).
If data type is a symbol, a predicate will be created by
appending a Q to the data type.
For example, positive integers are a subset of integers.
To add this data type, use
AddDataType[PositiveInteger, Integer, Complex].
This will also defined a new query function called IsPositiveIntegerQ.
\item {\tt AddT} (in ``TransSupport.m'') \newline
AddT[transq, t1, t2] adds the two transforms t1 and t2 together
and determines the new region of convergence. The new
transform is returned as a list. AddT[transq, t1, t2, lowerlimit]
uses lowerlimit as the lower limit on the region of convergence
values when combining ROC's (default is 0).
\item {\tt Aliasby} (in ``SigProc.m'') \newline
Aliasby[m,w][x] represents the aliasing of x, a continuous-frequency
signal, by replicating it every (2 Pi / m) in w and dividing the
result by m.
\item {\tt AllDataTypes} (in ``DataType.m'') \newline
AllDataTypes is the universal set of all data types.
Symbols cannot be associated with this data type.
\item {\tt AllSubsets} (in ``SupCode.m'') \newline
AllSubsets[set] returns a list of all subsets of set.
AllSubsets[set, function] applies function to every subset
with more than one element.
For example, AllSubsets[ \{v1,v2,v3\}, Plus ] returns
\{v1, v2, v3, v1 + v2, v1 + v2, v1 + v3, v1 + v2 + v3\}.
Note that the subset does not contain the null set.
\item {\tt Analog} (in ``FilterSupport.m'') \newline
Analog is continuous-time signal processing.
\item {\tt AnalogFilter} (in ``FilterDesign.m'') \newline
AnalogFilter[class, time-variable, order, epsilon, A,
transition-ratio, cutoff-frequency] will return an object with
head CIIR that represents a one-dimensional lowpass analog filter.
Here, class is one of Bessel, Butterworth, ChebyshevI, ChebyshevII,
Elliptic.
The last four arguments are filter parameters.
The value of the cutoff-frequency defaults to 1.
See also FilterParameters and FilterOrder.
\item {\tt Area} (in ``Convolution.m'') \newline
Area[ar] is an object representing the area under a Dirac delta
function.
A Dirac delta function is usually written as C Delta[t - t0],
where C is the area under the delta function and t0 is the location
of the delta function.
In F-interval form, C Delta[t - t0] becomes \{ Area[C], t0, t0 \}.
\item {\tt Arrow2D} (in ``SupCode.m'') \newline
Arrow2D[tail, plotwidth, plotheight] returns a graphics object
which has the shape of an arrow.
\item {\tt AssociateDataType} (in ``DataType.m'') \newline
AssociateDataType[symbol, datatype] will indicate to all Signal
Processing Packages that the symbol is of type datatype.
This in no way restricts assignments to that symbol.
For example, AssociateDataType[n, Integer] means that
IsIntegerQ[n] will always be True, as well as
IsRationalQ[n], IsRealQ[n], and IsComplexQ[n].
Also see DefConstant and UnAssociateDataType.
\item {\tt AssociateItem} (in ``SupCode.m'') \newline
AssociateItem[item, lookuplist, newlist] finds the location of
item in the lookuplist and returns the element of newlist in
that position.
If item is not is lookup list, Null is returned.
If item is a list, then a list of associations is returned.
\item {\tt AutoCorrelation} (in ``Convolution.m'') \newline
AutoCorrelation[e, v] computes the autocorrelation of expression e
(in the form of a list of F-intervals, an F-interval, or a function)
with respect to v.
The variable v is treated as either discrete and continuous
according to the value of the Domain option.
The default domain is the value of \$ConvolutionDomain.
\item {\tt Bandpass} (in ``FilterSupport.m'') \newline
Bandpass describes a filter that passes a band of frequencies
and rejects all others.
\item {\tt Bandstop} (in ``FilterSupport.m'') \newline
Bandstop describes a filter that rejects a band of frequencies
and passes all others.
\item {\tt Bessel} (in ``FilterSupport.m'') \newline
Bessel is a type of infinite impulse response (IIR) filter.
The step response of a lowpass Bessel function has low overshoot.
The transfer function is of the form d0 / Bn(s), where d0 is a
constant and Bn(s) is the nth-order Bessel polynomial.
The magnitude response of a lowpass Butterworth filter is smooth
(no ripples) and monotonically decreases with respect to frequency.
\item {\tt BesselPolynomial} (in ``FilterDesign.m'') \newline
BesselPolynomial[order, s] results from truncating a continued
fraction expansion representation of the unit delay exp(-s).
Bessel polynomials satisfy the recursion
B[n, s] = (2n - 1) B[n-1, s] + s\verb:^:2 B[n-2, s], with
B[0, s] = 1 and B[1, s] = s + 1.
\item {\tt BezoutNumbers} (in ``Multirate.m'') \newline
BezoutNumbers[a, b] gives the Bezout numbers of integers a and b.
That is, it returns \{lambda, mu\} so that lambda a + mu b == gcd(a,b).
\item {\tt BilinearTransformation} (in ``FilterSupport.m'') \newline
BilinearTransformation[omega, w, k] assumes that two of three
arguments have value and will set the value of the unknown parameter.
It returns a list of the three arguments.
BilinearTransformation[omega, w, k, h, s, z, t] will transform
the analog transfer function h = f(s) into a digital transfer
function g(z).
Now, if h is instead a function of t and not of s,
then the Bilinear transformation will be applied to the Laplace
transform of h. If h is an analog filter (see CIIR and CFIR),
then the result will be a digital filter (see IIR and FIR).
\item {\tt Butterworth} (in ``FilterSupport.m'') \newline
Butterworth is a type of infinite impulse response (IIR) filter
whose magnitude squared response is of the form 1/(1 + (w/wc)\verb:^:(2 n))
where w is the frequency variable, wc is the cutoff frequency,
and n is the filter order.
The magnitude response of a lowpass Butterworth filter is smooth
(no ripples) and monotonically decreases with respect to frequency.
\item {\tt CConvolve} (in ``SigProc.m'') \newline
CConvolve[t][x1, x2, ...] represents the continuous convolution in t
of functions x1, x2, ....
CConvolve[\{t1, t2, ...\}][x1, x2, ...] represents the multidimensional
continuous convolution in t1, t2, ... of functions x1, x2, ...
\item {\tt CFIR} (in ``FilterSupport.m'') \newline
CFIR[t, \{h0, h1, h2, ...\}] represents the finite impulse response
of an all-zero analog filter.
Input to the filter is specified as FIR[t, h] [ x[t] ],
where x[t] is some symbolic signal processing expression.
For the generalized N-dimensional FIR structure,
the argument t becomes a list of indices (like \{t1, t2\} for N=2)
and the feedback coefficients are in an N x N matrix.
Supports option Roots, which for 1-D filters is a list of zeroes.
\item {\tt CIIR} (in ``FilterSupport.m'') \newline
CIIR[t, \{a0, a1, a2, ...\}] represents the infinite impulse response
of an all-pole analog filter with gain 1, where a1, a2, ..., are the
feedback coefficients and a0 is the scaling factor of the output.
The Laplace transform of such an expression is
1 / ( a0 + a1 s + a2 s\verb:^:2 + ... ).
By default, the input to the filter is a Dirac delta function.
An alternate input h can be specified by the code
CIIR[t, \{a0, a1, a2, ...\}][h].
For the generalized N-dimensional IIR structure, the argument t
becomes a list of indices (like \{t1, t2\} for N=2) and the feedback
coefficients are specified by an N x N matrix.
Supports option Roots, which for 1-D filters is a list of poles.
\item {\tt CPulse} (in ``SigProc.m'') \newline
CPulse[l,t] defines a pulse which begins at t=0 and ends at t = l.
The CPulse has value 1 within the range (0,l),
0 outside this range, and 1/2 at the points t=0 and t=l.
A continuous-pulse center at the origin is written as
CPulse[l, t + l/2] or Shift[-l/2, t][CPulse[l, t]].
\item {\tt CStep} (in ``SigProc.m'') \newline
CStep[t], a.k.a. Unit[-1][t], is the unit step function
which is 1 for t $>$ 0, 0 for t $<$ 0, and 1/2 at t = 0.
It is commonly used for continuous expressions t.
See also Step and Unit.
\item {\tt CTFTData} (in ``Fourier.m'') \newline
CTFTData is the data-tag for the CTFT.
\item {\tt CTFTransform} (in ``Fourier.m'') \newline
CTFTransform[f, t] or CTFTransform[f, t, w] computes the
continuous-time Fourier transform of f. It has time argument(s) t
and frequency argument(s) w.
\item {\tt CTPiecewiseConvolution} (in ``Convolution.m'') \newline
CTPiecewiseConvolution[f, g, t] carries out the one-dimensional,
continuous-time piecewise convolution of f and g with respect to t.
See PiecewiseConvolution for valid representation of f and g.
Using F-interval notation \{function, left endpoint, right endpoint\},
a Dirac delta is meant when function = Area[$<$area$>$]
(where $<$area$>$ equals the area of under the impulse function) and
left endpoint = right endpoint (which is the location of the impulse).
\item {\tt ChebyshevI} (in ``FilterSupport.m'') \newline
ChebyshevI is a type of infinite impulse response (IIR) filter
whose magnitude squared response is of the form
1/(1 + e\verb:^:2 Tn(w/wc)\verb:^:2) where e controls passband ripple,
w is the frequency variable, and wc is the cutoff frequency.
The term Tn(s) is the nth-order Chebyshev polynomial.
The magnitude response of the stopband monotonically decreases
with respect to frequency.
\item {\tt ChebyshevII} (in ``FilterSupport.m'') \newline
ChebyshevII is a type of infinite impulse response (IIR) filter
whose magnitude squared response is of the form
1/(1 + e\verb:^:2 Xn(w/wc)\verb:^:2) where e controls stopband ripple,
w is the frequency variable, and wc is the cutoff frequency.
Here, Xn(w) = Tn(wr) / Tn(wr / w), where Tn(w) is the nth-order
Chebyshev polynomial.
The magnitude response of the passband
monotonically decreases with respect to frequency.
\item {\tt CirclePS} (in ``SupCode.m'') \newline
CirclePS[r] and CirclePS[r, p] will return a graphics object,
a circle of radius r with plotstyle p.
In Mathematica 2.0, CirclePS makes use of the Circle primitive.
\item {\tt Combine} (in ``SupCode.m'') \newline
Combine[object, joindata] sets the value of object to the
joining of object with joindata; however, if object has no
value, then object is set to joindata.
\item {\tt CombineDataType} (in ``DataType.m'') \newline
CombineDataType[ datatype1, datatype2, ...] resolves multiple
data types.
\item {\tt CommutableResamplingMatricesQ} (in ``Multirate.m'') \newline
CommutableResamplingMatricesQ[downsamplingmat, upsamplingmat]
returns True if the two resampling operations are commutable.
\item {\tt ComplexAntiSymmetric} (in ``DataType.m'') \newline
ComplexAntiSymmetric is an abstract data type.
It indicates that the real and imaginary components of a
complex-valued sequence (or function) are anti-symmetric.
See AssociateDataType.
\item {\tt ComplexQ} (in ``SupCode.m'') \newline
ComplexQ[z] returns True if z is a complex number, False otherwise.
\item {\tt ComplexSymmetric} (in ``DataType.m'') \newline
ComplexSymmteric is an abstract data type.
It indicates that the real and imaginary components of a
complex-valued sequence (or function) are symmetric.
See AssociateDataType.
\item {\tt ComplexTo2DCoord} (in ``SupCode.m'') \newline
ComplexTo2DCoord[x] returns the two-dimensional coordinate
corresponding to the complex form of x.
That is, a pair of values in the form \{ Re[x], Im[x] \} is returned.
\item {\tt ComplexTo2DCoordList} (in ``SupCode.m'') \newline
ComplexTo2DCoordList[zlist] returns a list of coordinates
corresponding to the complex form of each element in the
zlist.
That is, zlist is mapped through ComplexTo2DCoord.
\item {\tt ConjT} (in ``TransSupport.m'') \newline
ConjT[transq, X(s), s] implements T\{ Conj\{x(t)\} \} --$>$ X*(s*),
where X(s) is the transform of x(t).
\item {\tt ConstantQ} (in ``SupCode.m'') \newline
ConstantQ[x] returns True if x is always constant.
If x is an atom, then x is constant it is a number or it x has
a Constant attribute.
If x is a function of the form f[arg1, arg2, ...], then x is
considered to be constant if arg1, arg2, ..., are constant.
\item {\tt ConstantTerm} (in ``SupCode.m'') \newline
ConstantTerm[expr, x] returns the constant term of the
expression expr.
\item {\tt Continuous} (in ``SigProc.m'') \newline
Continuous is a possible value for a signal's domain.
\item {\tt ConvertFromList} (in ``Convolution.m'') \newline
ConvertFromList[l, t] converts a list of F-intervals in the form
\{f, t1, t2\} to a signal processing expression.
The new expression will contain either Delta, CStep, and CPulse
functions (continuous-time) or Impulse, Step, and Pulse functions
(discrete-time) according to the value of the Domain option.
The default domain is the value of \$ConvolutionDomain.
\item {\tt ConvertToList} (in ``Convolution.m'') \newline
ConvertToList[e, t] converts the expression e to a
list of F-intervals in the form \{fun, left, right\}.
The domain of the new expression is established according to the
value of the Domain option.
The default domain is the value of \$ConvolutionDomain.
\item {\tt Convolve} (in ``SigProc.m'') \newline
Convolve[n][x1, x2, ...] represents the discrete convolution in n of
functions x1, x2, ....
Convolve[\{n1, n2, ...\}][x1, x2, ...] represents the multidimensional
discrete convolution in n1, n2, ... of functions x1, x2, ...
\item {\tt ConvolveT} (in ``TransSupport.m'') \newline
ConvolveT[transq, convop, t1, t2] implements one dimension of the
transform of a convolution, Convolution[All, All, t][x1, x2], where
convop is the convolution operator, t1 is the transform of x1,
and t2 is the transform of x2.
\item {\tt CorrelationSequence} (in ``Correlation.m'') \newline
CorrelationSequence[x,n,z] or CorrelationSequence[X,n,z] will
return the correlation sequence as discrete-time function of n.
Note that the first argument can be either a sequence x[n] or
a z-transform X(z). Also note that the last two arguments are
optional.
\item {\tt DFT} (in ``SigProc.m'') \newline
DFT[L, n, k] is the forward discrete Fourier transform operator.
Here, L is the DFT length(s), n is the time-domain variable(s), and
k is the frequency-domain variable(s).
Multidimensional DFT's are supported.
Applying TheFunction to the DFT operator will invoke
the DFT rule base (object DFTransform) if loaded.
\item {\tt DFTData} (in ``DFT.m'') \newline
Data-tag for the symbolic DFT.
\item {\tt DFTransform} (in ``DFT.m'') \newline
DFTransform[function, NumberOfPoints, TimeVariables,
FourierVariables, options] returns the DFT of function,
where function is a function of TimeVariables defined from
0 to NumberOfPoints - 1. Note that only the first two arguments
are required and that DFTransform calls DTFTransform.
\item {\tt DSPAnalyze} (in ``DSPAnalyze.m'') \newline
DSPAnalyze[f, n] and DSPAnalyze[f, n, start, end]
will plot the real values of f[n] from n = Floor[start] to
n = Ceiling[end], print its z-transform, indicate conditions
for stability, display the pole-zero diagram, and plot the magnitude
and phase responses.
DSPAnalyze[f, \{n1,n2\}] and DSPAnalyze[f, \{n1,n2\}, \{s1,s2\}, \{e1,e2\}]
treat f as a function of two-variables n1 and n2.
The domain of the time-domain graph is n1 from s1 to e1 and
n2 from s2 to e2.
All non-variable symbols will be assigned a value of 1 when the
analyzer generates graphics (override this with options like a -$>$ 2).
\item {\tt DTFT} (in ``SigProc.m'') \newline
DTFT[n, w] is the forward discrete-time Fourier transform operator.
Here, n is the time-domain variable(s), and w is the frequency-domain
variable(s).
Multidimensional DTFT's are supported.
Applying TheFunction to the DTFT operator will invoke the DTFT
rule base (object DTFTransform) if loaded.
\item {\tt DTFTData} (in ``DTFT.m'') \newline
DTFTData is a data-tag.
\item {\tt DTFTransform} (in ``DTFT.m'') \newline
DTFTransform[function, in variable(s), out variable(s), options]
returns the discrete-time Fourier transform of the input function.
Note that this transform may rely on the z-transform and the
substitution z = Exp[I w], which is not valid if the region of
convergence does not include the unit circle. Also note that
only the first two arguments are required.
\item {\tt DTPiecewiseConvolution} (in ``Convolution.m'') \newline
DTPiecewiseConvolution[f, g, n] carries out the one-dimensional,
discrete-time piecewise convolution of f and g with respect to n.
See PiecewiseConvolution for the valid representations of f and g.
Using F-interval notation \{function, left endpoint, right endpoint\},
an impulse (Kronecker delta) function is meant when function = $<$value$>$
(where $<$value$>$ equals the strength of the impulse function) and
left endpoint = right endpoint (which is the location of the impulse).
\item {\tt DataType} (in ``DataType.m'') \newline
DataType[expr1, expr2, ...] returns the data type which results
in the combination of data types in expr1, expr2, ....
To associate a data type with a new function aa, use
aa/: DataType[ aa[args ] ] := newdatatype.
Use AssociateDataType to associate data types with symbols.
Use AddDataType to add more data types to the data type rules base.
\item {\tt DataTypeQ} (in ``DataType.m'') \newline
DataTypeQ[datatype1, datatype2, ...] returns True if every
passed data type is valid and recognized by the DataType rules base.
Use AddDataType to add more data types to the rules base.
\item {\tt DataTypes} (in ``DataType.m'') \newline
DataTypes[] returns a listing of all recognized abstracted
data types.
DataTypes[datatype] returns a list of all symbols
associated with datatype.
DataTypes[datatype1, datatype2, ...] returns a sorted table of
symbols associated with the data types datatype1, datatype2, ....
All symbols having an associated data type can therefore be found
by the code fragment DataTypes[ DataTypes[] ].
\item {\tt DefConstant} (in ``DataType.m'') \newline
DefConstant[symbol] simply sets the Constant attribute of symbol.
DefConstant[symbol, datatype] establishes the data type of the
symbol as datatype by calling AssociateDataType as well as
setting the symbol's Constant attribute.
\item {\tt DeleteFromTree} (in ``Tree.m'') \newline
DeleteFromTree[tree, node] deletes all nodes with info/name of node.
If the node is a parent, then the entire subtree is pruned.
\item {\tt Delta} (in ``SigProc.m'') \newline
Delta[expr] is the Dirac delta function.
The area under this functions is 1 but it only has value
at the origin.
That is, Integrate[ Delta[t] g[t], \{t, t1, t2\} ] is g[0]
if t1 $<$= 0 $<$= t2, 0 otherwise.
It differs from the Kronecker delta function Impulse[t].
\item {\tt DeltaPlot} (in ``SigProc.m'') \newline
DeltaPlot is a object that can generate a plot of only Dirac delta
functions or a combination of Dirac delta functions and another plot.
In the first case, either four or six arguments are passed:
deltafuns, t, xmin, xmax, ymin, ymax.
In the second case, either five or seven arguments are passed:
deltafuns, t, xmin, xmax, plot, ymin, ymax.
In both cases, ymin and ymax are the optional arguments.
DeltaPlot returns a list of plots suitable for sending to Show.
Note that 1-D Delta functions are plotted as arrows.
\item {\tt DerivativeT} (in ``TransSupport.m'') \newline
DerivativeT[transq, expr, s, m] applies the derivative operator
to the transform expr which is a function of s. The derivative is
taken m times if and only if expr satisfies transq.
\item {\tt DesignFilter} (in ``FilterSupport.m'') \newline
DesignFilter[domain, class, type, time-variable, deltap,
deltas, w1, w2, w3, w4] returns a filter expression (involving
IIR/FIR or CIIR/CFIR filter sections).
Domain is either Analog or Digital.
Possibilities for class include Butterworth,
ChebyshevI, ChebyshevII, and Elliptic.
Possible filter types are Lowpass, Highpass, Bandpass, and Bandstop.
For lowpass filters, the magnitude response of the passband resides
on [1, 1 - deltap] and the magnitude response of the stopband
occupies [0, deltas].
The last two arguments, w3 and w4, are only necessary for
bandpass and bandstop filters.
Frequencies w1, w2, w3, and w4 are measured in rad/sec and
should be given in ascending order.
\item {\tt Dialogue} (in ``SigProc.m'') \newline
Dialogue is an option for all of the symbolic transforms, the
differential/difference equations solvers, and more.
Possible settings are False, True, or All, for no, partial, or
full justification.
In the case of symbolic transforms, a setting of True or All will
cause the rule base to describe strategies being applied to compute
the transform as well as the functions (if any) which it could not
transform.
If it set to All, then the rule base will also display each step
of the transform reasoning.
\item {\tt Difference} (in ``SigProc.m'') \newline
Difference[k,n] represents the k-th backward difference with respect
to the variable n.
The first-order difference of f equals f[n] - f[n-1],
the second-order difference is f[n] - 2 f[n-1] + f[n-2], and so on.
Applying this operator to the sequence x[n] would be written as
Difference[k,n][ x[n] ].
\item {\tt Digital} (in ``FilterSupport.m'') \newline
Digital is discrete-time signal processing.
\item {\tt Dirichlet} (in ``SigProc.m'') \newline
Dirichlet[N, w] is the aliased sinc function.
which is defined as Sin[N w / 2] / ( N Sin [w / 2] ).
Aliases for Dirichlet are ASinc, AliasSinc, and AliasedSinc.
\item {\tt Discrete} (in ``SigProc.m'') \newline
Discrete is a possible value for a signal's domain.
\item {\tt DiscreteGraphics} (in ``SigProc.m'') \newline
DiscreteGraphics[\{\{x1,y1\}, \{x2,y2\}, ... \{xN,yN\}\}] will plot
the points as lines drawn from the x-axis to the y-value.
\item {\tt DistinctCosetVectors} (in ``Multirate.m'') \newline
DistinctCosetVectors[resmat] returns a sorted list of all of the
distinct coset vectors associated with the resampling matrix resmat.
DistinctCosetVectors[resmat, U\verb:^:-1, Lambda, V\verb:^:-1] finds all of the
distinct coset vectors of resmat from its Smith Form U Lambda V.
This is carried by finding the distinct coset vectors of the diagonal
matrix Lambda, mapping them by U\verb:^:-1, and then taking each vector
modulo the resampling matrix resmat.
The returned coset vectors are not sorted.
\item {\tt Domain} (in ``SigProc.m'') \newline
Domain is an option for many signal processing functions.
It is either Discrete or Continuous.
\item {\tt DomainScale} (in ``TransSupport.m'') \newline
DomainScale is an option for MagPhasePlot indicating the
scaling of the independent variable axis, Linear or Log,
for the magnitude plot.
\item {\tt Downsample} (in ``SigProc.m'') \newline
Downsample[m,n] represents the downsampling operator.
Downsampling resamples a function at the points n = 0, m, 2m, 3m, ...
In N dimensions, n is a list of N indices and m is an N x N matrix.
Applying TheFunction to f[n] which is downsampled in one dimension,
(written as Downsample[m, n][ f[n] ]) will produce f[m n].
\item {\tt DummyVariables} (in ``SigProc.m'') \newline
DummyVariables[dimension, variable] generates dimension dummy
variables with variable as the root.
For example, n can be generated by DummyVariables[1, n] or
DummyVariables[0, n].
As another example, DummyVariables[3, t] returns \{t1, t2, t3\}.
In this cases, the generated variables have the same context
as variable.
DummyVariables[dimension, variable, context] can
be used to specify another context/package.
\item {\tt Element} (in ``SupCode.m'') \newline
Element[list, n] returns the nth element of list.
Also, Element[l1, l2, ..., n] returns ln.
\item {\tt Elliptic} (in ``FilterSupport.m'') \newline
Elliptic is a type of infinite impulse response (IIR) filter
whose magnitude squared response is of the form
1/(1 + e\verb:^:2 Rn(w,L)\verb:^:2) where e controls ripple, w is the frequency
variable, and wc is the cutoff frequency.
Here, Rn(w, L) is called a Chebyshev rational function
such that L is a parameter describing ripple properties.
Elliptic filters have equiripple in the passbands and stopbands.
\item {\tt EmptyQ} (in ``SupCode.m'') \newline
EmptyQ[packet] returns True the packet of data is empty.
\item {\tt FIR} (in ``FilterSupport.m'') \newline
FIR[n, \{h0, h1, h2, ...\}] represents the finite impulse response
of an all-zero digital filter.
As a function of n, the response is actually equal to
h0, h1, h2, ..., for n = 0, 1, 2, ....
Note that FIR[n, 2] will be simplified to 2 Impulse[n].
FIR can also represent an all-zero filter.
In this case, the input x[n] to the filter is specified as
FIR[n, h] [ x[n] ], where x[n] is some symbolic
signal processing expression.
For the generalized N-dimensional FIR structure,
the argument n becomes a list of indices (like \{n1, n2\} for N=2)
and the feedback coefficients are in an N x N matrix.
\item {\tt FT} (in ``SigProc.m'') \newline
FT[t, w] is the forward continuous Fourier transform operator.
Here, t is the time-domain variable(s) and w is the
frequency-domain variable(s).
Applying TheFunction to this operator will invoke the continuous-time
Fourier transform rule base (object CTFTransform) if loaded.
\item {\tt FTDataType} (in ``DataType.m'') \newline
FTDataType[datatype] returns the data type of datatype after
it has been sent through a Fourier transform.
\item {\tt FVariables} (in ``DSupport.m'') \newline
FVariables is a data tag for the transform variables in a
Fourier transform.
\item {\tt FilterOrder} (in ``FilterSupport.m'') \newline
FilterOrder[filter-type, transition-ratio, nu] returns the filter
order for the lowpass filter that meets the transition ratio
(for digital filters, see BilinearTransformation)
and the filter parameter nu (which is a function of the passband
and stopband ripple parameters-- c.f. FilterParameters).
\item {\tt FilterParameters} (in ``FilterSupport.m'') \newline
FilterParameters[delta1, delta2, epsilon, A, Eripple, ATT, nu]
fills in the values of the missing parameters.
It assumes that either the passband ripple (delta1) and
the stopband ripple (delta2) or epsilon (controls ripple) and
A (1 / delta2) are given.
The values of Eripple, ATT, and nu will be computed and assigned
to the symbols passed into those slots.
Note that the passband takes on values between 1 and (1 - delta1)
and that the stopband takes on values between 0 and delta2.
The function returns a list of all seven parameters.
\item {\tt FilterTransform} (in ``FilterDesign.m'') \newline
FilterTransform[filter-domain, lowpassfilter, s, new-filter-type,
wc, wcnew, wcnewupper] transforms a lowpass filter with
cutoff frequency wc into either a lowpass or highpass filter
with a cutoff of wcnew or a bandpass or bandstop filter with
lower/upper cutoff frequencies of wcnew and wcnewupper.
Here, the new-filter-type can be Lowpass, Highpass, Bandpass, or
Bandstop.
\item {\tt FindRMinus} (in ``ROC.m'') \newline
FindRMinus[rminus1, rminus2] and FindRMinus[rminus1, rminus2,
lowerlimit] returns the greater of the two coordinates rminus1
and rminus2. This function and FindRPlus[] are used to find
the intersection of two regions of convergence.
\item {\tt FindRPlus} (in ``ROC.m'') \newline
FindRPlus[rplus1, rplus2] and FindRPlus[rplus1, rplus2, lowerlimit]
returns the lesser of the two coordinates rminus1 and rminus2.
This function and FindRMinus[] are used to find the intersection of
two regions of convergence.
\item {\tt Finish} (in ``DFT.m'') \newline
Finish is a data-tag for the DFT.
\item {\tt FourierSimplify} (in ``DSupport.m'') \newline
FourierSimplify[x] applies exponential to trigonometric rewrite
rules to expression x.
\item {\tt GenerateCode} (in ``SupCode.m'') \newline
GenerateCode[object] converts object to a string (if necessary)
and then evaluates it (translates it to Mathematica code).
\item {\tt GeneratePattern} (in ``SupCode.m'') \newline
GeneratePattern[namestring] generates a symbol with the name
equal to namestring followed by an underscore, which makes the
object be a pattern which can be used for pattern matching.
For example, GeneratePattern[ a ] yields the pattern (a ).
\item {\tt GenerateSymbol} (in ``SupCode.m'') \newline
GenerateSymbol[namestring], GenerateSymbol[namestring, trailer],
and GenerateSymbol[namestring, trailer, header], generate a
symbol by concatenating header, namestring, and trailer.
\item {\tt GetAllExponents} (in ``SupCode.m'') \newline
GetAllExponents[expr, x] returns all exponents of the
term x in the expression expr.
GetAllExponents[z\verb:^:3 + 2 z\verb:^:6, z] returns \{6, 3\}.
\item {\tt GetAllFactors} (in ``SupCode.m'') \newline
GetAllFactors[expr, x] returns all factors of the
term x in the expression expr.
GetAllFactors[z\verb:^:3 + 2 z\verb:^:6, z] returns \{1, 2\}.
GetAllFactors[z\verb:^:-3 + 2 z\verb:^:-6, z] returns \{1/2, 1\}.
\item {\tt GetDeltaFunctions} (in ``SigProc.m'') \newline
GetDeltaFunctions[function, variable(s)] will extract
all delta functions from the argument function. See also DeltaPlot.
\item {\tt GetOperatorVariables} (in ``SupCode.m'') \newline
GetOperatorVariables[op] returns the variable(s) in the
parameterized operator op.
By default, GetOperatorVariables[ op[par1, par2, ...] ]
returns the first parameter, par1.
\item {\tt GetPosition} (in ``DataType.m'') \newline
GetPosition[list, element] returns the position which element
occurs in the list as an integer.
\item {\tt GetRMinus} (in ``ROC.m'') \newline
GetRMinus returns the value of the Rminus component of the
region of convergence contained in the passed argument.
So, GetRMinus[ZTransData[x,rm,rp,z]] returns the value of rm;
GetRMinus[Rminus[x]] returns x; and GetRMinus[x] returns x.
\item {\tt GetRPlus} (in ``ROC.m'') \newline
GetRPlus returns the value of the Rplus component of the
region of convergence contained in the passed argument.
GetRPlus[ZTransData[x,rm,rp,z]] returns the value of rp;
GetRPlus[Rplus[x]] returns x; and GetRPlus[x] returns x.
\item {\tt GetRoot} (in ``SupCode.m'') \newline
GetRoot[rule] extracts the value from an expression like
\{z -$>$ 0.\}, which is 0. in this case.
\item {\tt GetRootList} (in ``SupCode.m'') \newline
GetRootList[p, x] returns a list of the approximate numerical roots
of expression p, a function of x, with infinite roots removed.
GetRootList[p, x, filter] applies filter to the list of roots
returned by the Solve function (defaults to N).
\item {\tt GetStateField} (in ``SupCode.m'') \newline
GetStateField[state, field] returns the value of the slot
field n the list state.
\item {\tt GetValue} (in ``SupCode.m'') \newline
GetValue[f[n], n, n0] finds the numeric value of f[n] at n = n0
and GetValue[f[n1,n2], \{n1,n2\}, \{n01, n02\}] finds the numeric
value of f[n1,n2] at n1 = n01 and n2 = n02.
When the first argument has the variables embedded in it,
two arguments are sometimes enough: GetValue[ object, n0 ].
This is true when the object is an abstract signal.
\item {\tt GetVariables} (in ``SupCode.m'') \newline
GetVariables[expr] returns a list of all of the variables in
the expression expr.
See VariableQ for the definition of a variable.
\item {\tt HasAttributes} (in ``SupCode.m'') \newline
HasAttributes[symbol, attribute1, attribute2, ...] returns True
if the evaluation of symbol is another symbol and the attributes
to be checked are a subset of the attributes of this other symbol.
HasAttributes[Plus, \{Listable, Orderless\}] would return True.
\item {\tt Highpass} (in ``FilterSupport.m'') \newline
Highpass describes a filter that passes all frequencies above
a cutoff frequency and rejects all others.
\item {\tt IIR} (in ``FilterSupport.m'') \newline
IIR[n, \{a0, a1, a2, ...\}] represents the infinite impulse response
of an all-pole filter with gain 1, where a1, a2, ..., are the
feedback coefficients and a0 is the scaling factor of the output.
In discrete time, the output of IIR is the solution to y[n]
in the difference equation a0 y[n] + a1 y[n-1] + ... + aN y[n - N] =
impulse[n], with y[n] = 0 for n $<$ 0.
By default, the input into the filter (a.k.a. the forcing function)
is an impulse.
An alternate input h can be specified by the code
IIR[n, \{a0, a1, a2, ...\}][h].
For the generalized N-dimensional IIR structure, the argument n
becomes a list of indices (like \{n1, n2\} for N=2) and the feedback
coefficients are specified by an N x N matrix.
\item {\tt IIRFunction} (in ``FilterSupport.m'') \newline
IIRFunction[n, coeffs] and IIRFunction[n, coeffs, input] generate
the object IIRFunction[n, coeffs, input, TheFunction -$>$ hiir] that
represents a digital IIR filter with feedback coefficients coeffs
(see IIR for meaning) and input function input.
When n is an integer or real-valued integer, IIRFunction will return
the value of the filter computed at that sample.
For negative n, the value of IIRFunction is zero but the
value of hiir is the value of the input function (this allows
initial conditions to be specified in the input function).
Here, hiir is the actual recursive object that computes
values of the IIR filter only as needed.
To see what values have already been computed, type ??$<$hiir slot$>$.
\item {\tt Imaginary} (in ``DataType.m'') \newline
Imaginary is an abstract data type. See AssociateDataType.
\item {\tt ImaginaryQ} (in ``SupCode.m'') \newline
ImaginaryQ[z] returns True if z is a number whose real part is zero.
\item {\tt Impulse} (in ``SigProc.m'') \newline
Impulse[n] is the unit Kronecker Delta function.
At n = 0, the function evaluates to 1.
Elsewhere, it evaluates to 0.
\item {\tt InRange} (in ``SupCode.m'') \newline
InRange[a, b, c, amin, cmax, leftcompare, rightcompare] returns
True if b in between a and c.
The inclusiveness of the interval a to c is determined by the
arguments leftcompare and rightcompare, each of which defaults to
LessEqual.
So, InRange[a, b, c] returns True if a $<$= b $<$= c.
Non-numeric values, like Infinity, can be used for amin and cmax,
which default to -Infinity and +Infinity, respectively.
\item {\tt IncList} (in ``SupCode.m'') \newline
IncList[list, start, end] will increment the first element of list.
If this becomes greater than the first element of end,
then the next element of list will be incremented, and so forth.
For example, IncList[\{9,0,0\}, \{0,0,0\}, \{10,10,10\}] would return
\{0,1,0\} and IncList[\{9,9,9\}, \{0,0,0\}, \{10,10,10\}] would return
\{10,10,10\}.
This is useful when enumerating values over an
n-dimensional rectangular prism.
\item {\tt InfCheck} (in ``ROC.m'') \newline
InfCheck[expr] returns Infinity if expr is any Infinity form;
otherwise, expr is returned.
\item {\tt InfinityQ} (in ``SupCode.m'') \newline
InfinityQ[a] will return True if a is Infinity, -Infinity,
ComplexInfinity, DirectedInfinity[], or DirectedInfinity[r].
\item {\tt InformUserQ} (in ``TransSupport.m'') \newline
InformUserQ[x] returns True if the options in object x contain
Dialogue -$>$ All or Dialogue -$>$ True. It also returns True
if x is All or True.
\item {\tt InitTree} (in ``Tree.m'') \newline
InitTree[root] returns an empty tree with a root of root.
\item {\tt IntegerVectorQ} (in ``Multirate.m'') \newline
IntegerVectorQ[arg] returns True if arg is a vector whose
elements are integers.
\item {\tt IntegrateT} (in ``TransSupport.m'') \newline
IntegrateT[transq, t, variable, lower-limit, upper-limit] integrates
the transform t (with respect to variable) from lower-limit to
upper-limit. The resulting transform is returned as a list.
\item {\tt Interleave} (in ``SigProc.m'') \newline
Interleave[n][x0, x1, ...] interleaves samples of signals
x0, x1, ..., which are functions of n.
This is only applicable to discrete signals.
\item {\tt IntersectsROC} (in ``ROC.m'') \newline
Intersects[rm1,rp1,rm2,rp2] returns True if the interval (rm1,rp1)
overlaps with the interval (rm2,rp2) in any way. Therefore,
IntersectsROC will return False when the two intervals only overlap
at endpoints.
\item {\tt IntervalQ} (in ``Convolution.m'') \newline
IntervalQ[x] returns True if the argument x is an F-interval of
the form \{f, t1, t2\} where none of f, t1, or t2 are lists and
False otherwise.
\item {\tt IntervalsToFunction} (in ``SigProc.m'') \newline
IntervalsToFunction[interlist, n, step, pulse]
will translate the list of functions and intervals (interlist)
into a signal expression as a function of n.
Each element in the interlist is a list of three elements:
$<$function of n$>$, $<$n minus$>$, and $<$n plus$>$.
The function $<$function of n$>$ will be defined for
$<$n minus$>$ $<$= n $<$= $<$n plus$>$.
Note that $<$n minus$>$ can be an integer or -Infinity and
that $<$n plus$>$ can be an integer or Infinity.
The default values are n = Global`n,
step = Step, and pulse = Pulse.
This function also works for when n represents a continuous variable
(step = CStep and pulse = CPulse).
\item {\tt InvCTFTransform} (in ``Fourier.m'') \newline
InvCTFTransform[f, w, t] computes the inverse continuous time
Fourier transform of f with frequency arguments w and time
arguments t.
\item {\tt InvDFT} (in ``SigProc.m'') \newline
InvDFT[L, k, n] is the inverse discrete Fourier transform operator.
Here, L is the DFT length(s), n is the time-domain variable(s), and
k is the frequency-domain variable(s).
Multidimensional inverse DFT's are supported.
Applying TheFunction to the InvDFT operator will invoke the
inverse DFT rule base (object InvDFTransform) if loaded.
\item {\tt InvDFTransform} (in ``DFT.m'') \newline
InvDFTransform[function, NumberOfPoints, FourierVariables,
TimeVariables, options] takes the inverse DFT of function,
where function is a function of FourierVariables defined from
0 to NumberOfPoints - 1. Note that only the first two arguments
are required and that InvDFTransform calls InvDTFTransform.
\item {\tt InvDTFT} (in ``SigProc.m'') \newline
InvDTFT[w, n] is the inverse discrete-time Fourier transform
operator.
Here, n is the time-domain variable(s), and w is the
frequency-domain variable(s).
Multidimensional inverse DTFT's are supported.
Applying TheFunction to the InvDTFT operator will invoke the
inverse DTFT rule base InvDTFTransform if loaded.
\item {\tt InvDTFTransform} (in ``DTFT.m'') \newline
InvDTFTransform[function, in variable(s), out variable(s), options]
return the inverse discrete-time Fourier transform (inverse DTFT)
of the input function.
The first two arguments are required.
By default, the inverse DTFT rule base will apply the definition
of the inverse DTFT when all other attempts to find the inverse
have failed.
\item {\tt InvFT} (in ``SigProc.m'') \newline
InvFT[w, t] is the inverse discrete Fourier transform operator.
Here, t is the time-domain variable(s) and w is the
frequency-domain variable(s).
Multidimensional Fourier transforms are supported.
Applying TheFunction to this operator will invoke the inverse
continuous-time Fourier transform rule base InvCTFTransform if loaded.
\item {\tt InvL} (in ``SigProc.m'') \newline
InvL[s, t] is the inverse Laplace transform operator.
Applying TheFunction to the InvL operator will invoke the
bilateral inverse Laplace rule base InvLaPlace if loaded.
\item {\tt InvLaPlace} (in ``InvLaPlace.m'') \newline
InvLaPlace[f, s] and InvLaPlace[f, s, t] gives the multidimensional
bilateral inverse Laplace transform of f.
A region of convergence can be specified by using
InvLaPlace[\{f, rm, rp\}, s, t], where rm is R- and rp is R+
in the region (strip) of convergence: R- $<$ Re(s) $<$ R+.
Note that InvLaPlaceTransform is an alias for InvLaPlace.
\item {\tt InvZ} (in ``SigProc.m'') \newline
InvZ[z, n] is the inverse z-transform operator.
Applying TheFunction to the InvZ operator will invoke the inverse
z-transform rule base InvZTransform if loaded.
\item {\tt InvZTransform} (in ``InvZTransform.m'') \newline
InvZTransform[e,z] or InvZTransform[e,z,n] gives the inverse
z-transform of e. Here, e can be a function of z, a list, or
a z-transform object (see ZTransData). As a list, e should
contain three elements: F[z], rminus, and rplus, such that
the region of convergence is rminus $<$ $|$z$|$ $<$ rplus. If e is
a z-transform object, then the inverse z-transform is simply
InvZTransform[e] because e contains all necessary information.
If the returned expression is not the form you desire, then
apply Simplify[], Cancel[], Together[], etc., to the expression.
\item {\tt InvalidInvLTransformQ} (in ``LSupport.m'') \newline
InvalidInvLTransformQ[trans] returns True if the inverse Laplace
transform rule base did not successfully finish the transform.
\item {\tt InvalidInvZTransformQ} (in ``ZSupport.m'') \newline
InvalidInvZTransformQ[x] returns True if the result from a
call to InvZTransform was not a valid inverse z-transform.
This occurs when the object myinvz exists in expression x.
\item {\tt InvalidLTransformQ} (in ``LSupport.m'') \newline
InvalidLTransformQ[trans] returns True if the forward Laplace
transform rule base did not successfully finish the transform.
\item {\tt InvalidZTransformQ} (in ``ZSupport.m'') \newline
InvalidZTransformQ[x] returns True if a call exists to
the function MyZTransform in expression x; that is, True
is returned if the result from a call to Z or ZTransform
was not a valid Z transform.
\item {\tt Irrational} (in ``DataType.m'') \newline
Irrational is an abstract data type. See AssociateDataType.
\item {\tt IrrationalQ} (in ``DataType.m'') \newline
IrrationalQ[atom] returns True if the atom represents a number
which is irrational. IrrationalQ[Pi] is True.
\item {\tt IsComplexQ} (in ``DataType.m'') \newline
IsComplexQ[expression] returns True if the expression could
be considered complex-valued. IsComplexQ[1.0] is True.
\item {\tt IsImaginaryQ} (in ``DataType.m'') \newline
IsImaginaryQ[expression] returns True if the expression could
be considered imaginary.
\item {\tt IsIntegerQ} (in ``DataType.m'') \newline
IsIntegerQ[expression] returns True if the expression could
be considered integer-valued.
\item {\tt IsIrrationalQ} (in ``DataType.m'') \newline
IsIrrationalQ[expression] returns True if the expression could
be considered irrational.
\item {\tt IsRationalQ} (in ``DataType.m'') \newline
IsRationalQ[expression] returns True if the expression could
be considered rational. IsRationalQ[1] is True.
\item {\tt IsRealQ} (in ``DataType.m'') \newline
IsRealQ[expression] returns True if the expression could
be considered real-valued.
\item {\tt KVariables} (in ``DFT.m'') \newline
KVariables is a data-tag for the DFT.
\item {\tt KeepNormalized} (in ``ZSupport.m'') \newline
KeepNormalized[zexpr, fun, zvars] keeps the z-transform
expression zexpr in negative powers of z after the function
fun is applied to zexpr. If an optional fourth argument
is present, then the function fun[zexpr, z] is called instead
of fun[zexpr].
\item {\tt L} (in ``SigProc.m'') \newline
L[t, s] is the forward Laplace transform operator.
Applying TheFunction to the L operator will invoke the bilateral
Laplace rule base if loaded.
\item {\tt LForm} (in ``LSupport.m'') \newline
LForm[transform] returns True if the transform is a valid
Laplace transform with a head of Transform or List.
\item {\tt LMultiDROC} (in ``LSupport.m'') \newline
LMultiDROC[old-Laplace-transform, new-Laplace-transform]
combines the transform functions, regions of convergence, and
the transform variables in order to produce a multidimensional
transform.
\item {\tt LSolve} (in ``LSolve.m'') \newline
LSolve[ diffequ == drivingfun, y[t] ] solves the differential
equation diffequ = drivingfun, where diffequ is a linear constant
coefficient differential equation and drivingfun is the driving
function (a function of t).
Thus, diffequ has the form a0 y[t] + a1 y'[t] + ....
One can specify initial values; e.g.,
LSolve[ y''[t] + 3/2 y'[t] + 1/2 y[t] == Exp[a t],
y[t], y[0] -$>$ 4, y'[0] -$>$ 10 ].
A differential equation of N terms needs N-1 initial conditions.
All unspecified conditions are considered to be zero.
LSolve can justify its answers.
\item {\tt LTransData} (in ``ROC.m'') \newline
LTransData is a data tag for a valid Laplace transform object.
\item {\tt LTransformQ} (in ``LSupport.m'') \newline
LTransformQ[x] returns True if the datum x is of the form
LTransData[X, rm, rp, s], where X is the LaPlace transform,
rm is the Rminus component of the region of convergence,
rp is the Rplus component of the region of convergence, and
s is the variable(s) in the LaPlace transform.
\item {\tt LVariables} (in ``ROC.m'') \newline
LVariables is a data tag for variables in a Laplace transform object.
\item {\tt LaPlace} (in ``LaPlace.m'') \newline
LaPlace[e, t] or LaPlace[e, t, s] gives the two-sided Laplace
transform of the expression e, which is a function of t, by
returning an object of four slots tagged by LTransData:
$<$transform$>$, $<$rminus$>$, $<$rplus$>$, $<$laplace variables$>$.
The Region of Convergence (ROC) is defined as
$<$rminus$>$ $<$ Re\{s\} $<$ $<$rplus$>$.
Note that the returned ROC is either the actual ROC or a subset
of the actual ROC.
In two dimensions, LaPlace[e, \{t1, t2\}, \{s1, s2\}]
is the same as LaPlace [ LaPlace[e, t1, s1], t2, s2 ].
This notation extends naturally to higher dimensions.
Note that the right-sided transform is specified by
multiplying the expression by CStep[t].
Also, LaPlaceTransform is an alias for LaPlace.
\item {\tt LineImpulse} (in ``SigProc.m'') \newline
LineImpulse[nlist, coefflist] represents a line impulse where
nlist is a list of variables like \{n1,n2,n3\} and coefflist is
a corresponding list of coefficients like \{1,2,3\}.
For the previous lists, the line impulse is a set of impulse
along the line n1 = 2 n2 = 3 n3.
\item {\tt LineImpulsemDT} (in ``TransSupport.m'') \newline
LineImpulsemDT[transq, expr, s, slist, nleft, fun] applies rules for
evaluating multidimensional transforms which involve line impulses,
like the z-transform of f[n1,n2] Impulse[n1 - n2] or the Laplace
transform of f[t1,t2] Delta[t1 - t2]. In the both cases, the
impulse can be removed by setting n1=n2 or t1=t2, which yields a
one-dimensional function. The resulting 1D transform is then
altered by the rule z = z1 z2 or s = s1 + s2, respectively.
Here, the argument fun is Times for the z-transform and Plus for
the Laplace transform. Note that these rules are only applied if
expr is a valid transform, which occurs if transq[expr] evaluates
to True.
\item {\tt Linear} (in ``TransSupport.m'') \newline
Linear is a possible value for axis scaling. See MagPhasePlot.
\item {\tt ListQ} (in ``SupCode.m'') \newline
ListQ[expr] gives True if expr is a List, and False otherwise.
\item {\tt Lowpass} (in ``FilterSupport.m'') \newline
Lowpass describes a filter that passes all frequencies below
a cutoff frequency and rejects all others.
\item {\tt MagPhasePlot} (in ``TransSupport.m'') \newline
MagPhasePlot[freqresp, \{w, wmin, wmax \}] plots the magnitude
and phase response over the specified range of frequencies.
It returns a list of two elements: the magnitude plot and the
phase plot.
The two-dimensional version has the form
MagPhasePlot[freqresp, \{w1, wmin1, wmax1\}, \{w2, wmin2, wmax2\}].
The default options are initially biased for continuous-time
frequency responses of digital signals.
MagnitudePhasePlot is an alias for MagPhasePlot.
\item {\tt MagRangeScale} (in ``TransSupport.m'') \newline
MagRangeScale is an option for MagPhasePlot indicating the
scaling of the dependent variable axis, Linear or Log,
for the magnitude plot.
A setting of Null disables the generation of the phase plot.
\item {\tt MakeLObject} (in ``LSupport.m'') \newline
MakeLObject[l] and MakeLObject[l, slist] convert the LaPlace
transform information in list l into the standard object form
LTransData[x, Rminus[rm], Rplus[rp], LVariables[slist]].
Here x is the LaPlace transform, rm is the lower bound on the
strip of convergence, rp is the upper bound on the strip of
convergence, and slist is the list of LaPlace variables used
in the transform.
\item {\tt MakeZObject} (in ``ZSupport.m'') \newline
MakeZObject[l] and MakeZObject[l, zlist] converts the
z-transform information in list l into the standard object
form ZTransData[x, Rminus[rm], Rplus[rp], ZVariables[zlist]].
Here, x is the z-transform, rm is the lower bound on the
region of convergence, rp is the upper bound on the region
of convergence, and zlist is the list of z variables used in
the transform.
\item {\tt MixedPolynomialQ} (in ``SupCode.m'') \newline
MixedPolynomialQ[p] and MixedPolynomialQ[p,x] return
return True if p is a polynomial in negative and positive
(mixed) powers of x.
Note that rational numbers like 5/6 and 1 are polynomials.
MixedPolynomialQ[x + x\verb:^:-1, x] is True.
\item {\tt MultT} (in ``TransSupport.m'') \newline
MultT[transq, t1, t2] multiplies the transforms t1 and t2 together.
MultT[transq, t1, t2, lowerlimit] uses lowerlimit as the lower
limit on the region of convergence (ROC) when combining the ROC's of
t1 and t2.
\item {\tt MultiDInvTransform} (in ``TransSupport.m'') \newline
MultiDInvTransform[expression, transvar, timevar, options, transq,
transform, makeobject, tdefault] finds the multidimensional inverse
transform of expression by one call to transform per dimension.
Here, transq, transform, and makeobject are function heads.
\item {\tt MultiDTransform} (in ``TransSupport.m'') \newline
MultiDTransform[makefun, transform, transtest, expr, expr-vars,
def-trans-var, trans-vars] finds the multidimensional transform
by calling transform once per dimension. If a call to transform
produces an incomplete (invalid) transform, then the
multidimensional transform does not exist and this routine is
exited. The dimension of the transform is determined from
the number of expr-vars (which equals the number of trans-vars).
Here, expr is transformed.
\item {\tt MyApart} (in ``SupCode.m'') \newline
MyApart[ rational polynomial, x ] decomposes the rational
polynomial into a sum of fractions whose numerators are of
the form (x + b)\verb:^:n where b is a constant and n is an integer.
MyApart[rational polynomial, x, filter] specifies a filter to be
placed on the output of the Solve command used to root the
denominator: Identity for rational and N for real-valued roots.
The default is Identity.
In Mathematica 1.2, MyApart is about 25 times slower than Apart.
\item {\tt MyCollectAll} (in ``SupCode.m'') \newline
MyCollectAll[ expression, var ] attempts to collect all
subexpressions of expression in terms of var.
\item {\tt MyFreeQ} (in ``SupCode.m'') \newline
MyFreeQ[expr, form], when form is not a list, yields True if no
subexpression in expr matches form.
If form is a list, then True is returned if expr is free of
each element of form.
This is similar to MyFreeQ[expr, form1, form2, ...] which expands to
MyFreeQ[expr, form1] and MyFreeQ[expr, form2] and ....
\item {\tt MyMessage} (in ``SupCode.m'') \newline
MyMessage[message-label, return-value, arg1, arg2, ...] first calls
Message[message-label, arg1, arg2, ...] and then returns return-value.
\item {\tt MyTogether} (in ``SupCode.m'') \newline
MyTogether[x] puts the expression x over a common denominator.
This is the same as Together[x] without the effect of Cancel.
This function is compatible with DFT expressions.
\item {\tt NegExponent} (in ``SupCode.m'') \newline
NegExponent[poly, x] returns the maximum exponent of x\verb:^:-1.
\item {\tt NormalizeSamplingMatrix} (in ``Multirate.m'') \newline
NormalizeSamplingMatrix[sampmat] will decompose the sampling matrix
sampmat into a diagonal matrix D and a normalized sampling matrix V.
The results are returned as \{ D, V \}.
\item {\tt NormalizedQ} (in ``SupCode.m'') \newline
NormalizedQ[e,x] gives True if the constant term is one
or zero, and gives False otherwise.
\item {\tt NullPlot} (in ``SupCode.m'') \newline
NullPlot is a 2-d graphics object which only contains the origin.
\item {\tt OperatorInOperExpr} (in ``SigProc.m'') \newline
OperatorInOperExpr[ operator expression ] returns the full
operator in operator expression.
For example, Shift[2,n] would be returned from
OperatorInOperExpr[ Shift[2,n][x[n]] ].
\item {\tt OperatorName} (in ``SigProc.m'') \newline
OperatorName[ operator expression ] returns the head of the
expression.
For example, OperatorName[ Shift[2,n][x[n]] ] will return Shift.
\item {\tt ParametersInOperExpr} (in ``SigProc.m'') \newline
ParametersInOperExpr[ operator expression ] returns the parameters
of the operator in operator expression.
For example, (2,n) would be returned from
ParametersInOperExpr[ Shift[2,n][x[n]] ].
\item {\tt PatternQ} (in ``SupCode.m'') \newline
PatternQ[expr] returns True if the head of expr is Pattern.
\item {\tt Periodic} (in ``SigProc.m'') \newline
Periodic[k,n][f] indicates that f is a function of n which is
periodic with period of k.
\item {\tt PhaseRangeScale} (in ``TransSupport.m'') \newline
PhaseRangeScale is an option for MagPhasePlot indicating the
scaling of the dependent variable axis, Linear or Log,
for the phase plot. A setting of Null disables the generation
of the phase plot.
\item {\tt PiecewiseConvolution} (in ``Convolution.m'') \newline
PiecewiseConvolution[f, g, v] convolves the piecewise functions
f and g with respect to the variable t.
In this context, a function is represented in a piecewise fashion:
(1) as F-intervals of the form \{fun, left, right\},
(2) as a list of F-intervals, or (3) as an expression.
An F-interval has the form \{function, left endpoint, right endpoint\}.
The F-interval notation represents a finite-extent function or
sequence when the endpoints do not equal infinity.
The result of convolution is always returned as a list of F-intervals.
The variable v is treated as either discrete and continuous
according to the value of the Domain option.
The default domain is the value of \$ConvolutionDomain,
which can be reset by the SetConvolutionDomain function.
See also CTPiecewiseConvolution and DTPiecewiseConvolution.
\item {\tt PlotList} (in ``Convolution.m'') \newline
PlotList[l, \{v, vstart, vend\}] plots the piecewise function l vs. v.
The variable v is treated as either discrete and continuous
according to the value of the Domain option.
The default domain is the value of \$ConvolutionDomain.
\item {\tt PointwisePlot} (in ``SupCode.m'') \newline
PointwisePlot[coordlist, text] and
PointwisePlot[coordlist, text, multiplicitytext]
will plot the coordinates in coordlist as text
for 2-D and 3-D graphics.
An optional fourth argument specifies the size of the font to use.
For multiple occurrences of the same coordinate,
the object multiplicitytext is displayed.
The last two arguments are usually symbols, numbers, or
FontForm objects.
\item {\tt PoleZeroPlot} (in ``TransSupport.m'') \newline
PoleZeroPlot[transform-object] plots the poles and zeros of the
transform function as well as the region of convergence. For the
z-transform, this function will also plot the unit circle and
shade the region of convergence (whenever the ROC does not cover the
entire z plane). To plot a transfer function f, use
PoleZeroPlot[f, transform-variable, rminus, rplus, zdomainflag].
In the two-dimensional case, the transform-variable, rminus, and
rplus are two-element lists. The two-dimensional pole-zero plot
has three cases: separable transform, symmetric transform, and
root map. The function returns the poles of the transform.
\item {\tt PolyphaseDownsample} (in ``SigProc.m'') \newline
PolyphaseDownsample[m, n][x, h] is equivalent to downsampling
x by m and then convolving the result with h.
\item {\tt PolyphaseUpsample} (in ``SigProc.m'') \newline
PolyphaseUpsample[l, n][x, h] is equivalent to upsampling
x by l and then convolving the result with h.
\item {\tt PrintIt} (in ``SupCode.m'') \newline
PrintIt[graphics, printer] will print out graphics on a printer.
If the printer is not specified, the default printer is used.
\item {\tt ProtectIt} (in ``SupCode.m'') \newline
ProtectIt[expr] evaluates expr.
If it evaluates to a symbol, that symbol will be write protected.
Rules can be written for that symbol,
but values can no longer be assigned to it.
\item {\tt Pulse} (in ``SigProc.m'') \newline
Pulse[len] and Pulse[len, n] define a pulse which begins at
n = 0 and ends at n = len - 1.
A discrete pulse centered at the origin is written as
Pulse[len, n + (len - 1)/2] or Shift[-(len - 1)/2, n][Pulse[len, n]].
Sometime, a pulse will be automatically simplified;
e.g., Pulse[0, n] is zero and Pulse[1, n] is really Impulse[n].
\item {\tt ROCPlot} (in ``TransSupport.m'') \newline
ROCPlot[\{rm, rp\}] will plot the region of convergence as a
shaded annular region. Possible options for ROCPlot are the
same as those for the Show (or Plot) command.
\item {\tt Radian} (in ``TransSupport.m'') \newline
Radian is a possible value for axis scaling. See MagPhasePlot.
\item {\tt RationalChebyshev} (in ``FilterDesign.m'') \newline
RationalChebyshev[n, x, xL, L] returns a rational polynomial which
is the nth order rational Chebyshev function evaluated at x
for parameters xL and L.
\item {\tt RationalFunctionQ} (in ``SupCode.m'') \newline
RationalFunctionQ[f,x] returns True if expression f is of the form
f = g(x) / h(x), where h(x) depends on x but g(x) does not have
to depend on x.
For example, 1 / ( x + 1 ) is a rational function
in x but x\verb:^:3 + x\verb:^:2 + x / ( x + 1) is not.
\item {\tt RationalGCD} (in ``SigProc.m'') \newline
RationalGCD[list] returns the greatest common divisor of the
numerators in list divided by the greatest common divisor of
the denominators in list.
\item {\tt RationalPolynomialQ} (in ``SupCode.m'') \newline
RationalPolynomialQ[p] and RationalPolynomialQ[p,x] return
True if p is a rational polynomial in x.
Note that rational numbers like 5/6 and 1 are also
rational polynomials.
\item {\tt RationalQ} (in ``SupCode.m'') \newline
RationalQ[m] returns True if m is a rational number.
If m is an integer, then this function also return True,
since the set of integers are a subset of rationals.
\item {\tt RealQ} (in ``SupCode.m'') \newline
RealQ[z] returns True if z is a floating-point number
(has a head of Real), False otherwise. See RealValuedQ.
\item {\tt RealValuedQ} (in ``SupCode.m'') \newline
RealValuedQ[z] gives True if z is a number whose imaginary
component is 0, and gives False otherwise. See RealQ.
\item {\tt ReplaceWith} (in ``SupCode.m'') \newline
ReplaceWith[oldexpr, newexpr] is a generalized way to specify
a substitution when the substitution may be either atomic
and a list of substitutions.
\item {\tt ResamplingMatrix} (in ``Multirate.m'') \newline
ResamplingMatrix[arg] returns True if arg is a square matrix
whose elements are integers and whose determinant is non-zero.
It returns False if arg is not a square matrix.
It also returns False if arg is a square matrix with one element
being a number that is not an integer.
Otherwise, it returns the conditions for which the square matrix
would be a resampling matrix.
\item {\tt ResamplingMatrixMod} (in ``Multirate.m'') \newline
ResamplingMatrixMod[n, N] implements the integer vector n
modulo a sampling matrix N which is defined as
n - N . Floor[ N\verb:^:-1 . n ].
The operation will be carried out if and only if n is an integer
vector, N is (or could be) a sampling matrix, and
N . n is a valid operation.
\item {\tt Rev} (in ``SigProc.m'') \newline
Rev[n][x] represents the operation of reversing the direction of x,
with respect to the variables(s) n.
\item {\tt RightSided} (in ``ZSolve.m'') \newline
RightSided is an option for ZSolve.
If True, then the solution to the difference equation will be
right-sided, left-sided otherwise.
\item {\tt Rminus} (in ``ROC.m'') \newline
Rminus[ $<$r-minus$>$ ] is the head for the R- value in a transform.
\item {\tt RootLocus} (in ``TransSupport.m'') \newline
RootLocus[f(z), z, \{freeparam, start, end, step\}] plots
the root locus of f(z) with respect to freeparam over the
range of start to end evaluated at increments of step.
RootLocus will generate three plots: the pole zero plot for
freeparam = start, the root locus, and the pole-zero plot for
freeparam = end.
The function returns a list of all three plots.
RootLocus supports the same options as does Show.
RootLocusPlot is an alias of RootLocus.
\item {\tt Rplus} (in ``ROC.m'') \newline
Rplus[ $<$r-plus$>$ ] is the head for the R+ value in a transform.
\item {\tt SPLessGreaterRules} (in ``SupCode.m'') \newline
SPLessGreaterRules are a collection of rules for simplifying
expressions involving inequalities.
\item {\tt SPSimplificationRules} (in ``SupCode.m'') \newline
SPSimplificationRules are a collection of rules common in
simplifying formulas encountered in signal processing.
These rules require too much overhead to encode them directly
into Mathematica.
\item {\tt SPfunctions} (in ``SupCode.m'') \newline
SPfunctions maintains a current list of those new routines
that have been loaded from the signal processing packages.
\item {\tt SPoperators} (in ``SupCode.m'') \newline
SPoperators maintains a current list of the new mathematical
operators that have been loaded from the signal processing packages.
\item {\tt SPsignals} (in ``SupCode.m'') \newline
SPsignals maintains a current list of those new signals
(mathematical functions) that have been loaded from the
signal processing packages.
\item {\tt SameFormQ} (in ``SupCode.m'') \newline
SameFormQ[pattern, expr1, expr2, ...] returns True if every
expression matches pattern via MatchQ.
Once an expression does not match,
this function immediately returns False.
\item {\tt ScaleAxis} (in ``SigProc.m'') \newline
ScaleAxis[l,w][x] represents the compression by a factor of l (an
integer) of the continuous w axis of x, which is usually a
continuous-frequency signal.
\item {\tt ScaleT} (in ``TransSupport.m'') \newline
ScaleT[transq, t, c] multiplies the transform t by c while leaving
the region of convergence unaltered. The resulting transform is
returned as a list.
\item {\tt ScalingFactor} (in ``SigProc.m'') \newline
ScalingFactor[expr, variable] returns the greatest common divisor
of all coefficients of powers of z in expr.
For example, ScalingFactor[ a z + a\verb:^:2 z\verb:^:2, z ] returns a.
This function enables the implementation of the similarity
property for transforms.
\item {\tt Second} (in ``SupCode.m'') \newline
Second[list] returns the second element of list.
\item {\tt SequencePlot} (in ``SigProc.m'') \newline
SequencePlot[f, \{n, start, end\}] plots real-valued 1-D sequences
and has the same options as Show.
You will have to apply Re or Im to f to plot the real or
imaginary values of the sequence, respectively.
SequencePlot[f, \{n1, start1, end1\}, \{n2, start2, end2\}] plots
2-D sequences and supports the same options as Plot3D.
\item {\tt SequenceToFunction} (in ``SigProc.m'') \newline
SequenceToFunction[seq], SequenceToFunction[seq, n], and
SequenceToFunction[seq, n, noffset] return the sequence seq,
\{x[noffset], ..., x[noffset + N - 1]\}, in symbolic form as a sum of
impulse functions.
For example, SequenceToFunction[\{1, 2, 3\}] -$>$
Impulse[n] + 2 Impulse[n - 1] + 3 Impulse[n - 2].
For multidimensional sequences, the argument n must be a list of
variables of appropriate length.
For example, SequenceToFunction[\{\{1,2\},\{3,4\}\}, \{n1, n2\}] -$>$
Impulse[n1,n2] + 2 Impulse[n1,n2-1] + 3 Impulse[n1-1,n2] +
4 Impulse[n1-1, n2-2].
\item {\tt SetConvolutionDomain} (in ``Convolution.m'') \newline
SetConvolutionDomain[domain] establishes the default convolution
domain as either Continuous or Discrete.
\item {\tt SetExclusion} (in ``SupCode.m'') \newline
SetExclusion[set1, set2, ...] returns a set equal to the union
of the sets minus the intersection of the sets.
\item {\tt SetStateField} (in ``SupCode.m'') \newline
SetStateField[state, field, value] will return a new state,
which is a copy of the list state except that the value of
the slot field will be equal to value.
\item {\tt ShadedAnnulus} (in ``TransSupport.m'') \newline
ShadedAnnulus[rm, rp] and ShadedAnnulus[rm, rp, angulartilt]
will create a 2-D graphics object that is an annulus
(rm $<$ radius $<$ rp) filled with uniformly spaced horizontal
lines rotated by angulartilt degrees.
\item {\tt Shift} (in ``SigProc.m'') \newline
Shift[m,v][x] represents the shifting of the expression x by m
samples to the right in the v direction, i.e. x[v] --$>$ x[v - m].
\item {\tt SignalPlot} (in ``SigProc.m'') \newline
SignalPlot[f, \{t, start, end\}] will plot f(t) as an one-dimensional,
continuous-time function.
It will show the real part as solid lines,
and the imaginary part as dashed lines.
Delta functions are plotted as upward pointing arrows.
SignalPlot[f, \{t1, start1, end1\}, \{t2, start2, end2\}] treats f
as a function of two variables t1 and t2.
SignalPlot supports the same options as Plot for 1-D signals
(functions) and Plot3D for 2-D signals (functions).
\item {\tt SignalsInOperExpr} (in ``SigProc.m'') \newline
SignalsInOperExpr[ operator expression ] returns the signal(s)
of the operator in operator expression.
For example, \{ x[n] \} would be returned from
SignalsInOperExpr[ Shift[2,n][x[n]] ].
Another version SignalsInOperExpr[ operator expression, operator ]
behaves as the first version if operator is the head of
operator expression; otherwise, operator expression is returned.
\item {\tt SimplifyList} (in ``Convolution.m'') \newline
SimplifyList[interval list, v] takes a list of F-intervals
each having the form \{f, t1, t2\} and returns a simplified sorted
list of F-intervals.
The interval list is treated as either a continuous-time or a
discrete-time function according the value of the Domain option.
The variable v is treated as either discrete and continuous
according to the value of the Domain option.
The default domain is the value of \$ConvolutionDomain.
\item {\tt Sinc} (in ``SigProc.m'') \newline
Sinc[t] is the unit sinc function which is the ratio of
Sin[t] over t. Note that Sinc[0] = 1.
\item {\tt SmithFormSameU} (in ``Multirate.m'') \newline
SmithFormSameU[smithfun, m1, m2] computes the Smith Form of the
integer matrix m1 so that m1 = u1 d1 v1.
The routine then uses u2 = u1 to decompose m2.
The first argument specifies which decomposition routine should
be used to decompose m1 (e.g., SmithNormalForm).
The routine returns \{cond, \{u1\verb:^:-1, d1, v1\verb:^:-1\}, \{u2\verb:^:-1, d2, v2\verb:^:-1\}\},
where cond is True of False depending on whether or not matrices
m1 and m2 can be decomposed using the same U.
\item {\tt SmithFormSameV} (in ``Multirate.m'') \newline
SmithFormSameV[smithfun, m1, m2] computes the Smith Form of the
integer matrix m1 so that m1 = u1 d1 v1.
The routine then uses v2 = v1 to decompose m2.
The first argument specifies which decomposition routine should
be used to decompose m1 (e.g., SmithNormalForm).
The routine returns \{cond, \{u1\verb:^:-1, d1, v1\verb:^:-1\}, \{u2\verb:^:-1, d2, v2\verb:^:-1\}\},
where cond is True of False depending on whether or not matrices
m1 and m2 can be decomposed using the same U.
\item {\tt SmithNormalForm} (in ``Multirate.m'') \newline
SmithNormalForm[A] returns a list of three matrices
U\verb:^:-1, D, and V\verb:^:-1 such that the m x n resampling matrix A
equals U D V where U (m x m) and V (n x n) are integer matrices
with determinants of +1 or -1 and D is a diagonal matrix
of integer components such that $|$det(D)$|$ = $|$det(A)$|$.
The algorithm follows Kaufmann's \{Integer and Mixed Programming\}.
Note that this factorization is not unique.
SmithNornamlForm supports a Dialogue option.
If True or All, SmithNormalForm will show immediate steps.
See also SmithOrderedForm and SmithReducedForm.
\item {\tt SmithOrderedForm} (in ``Multirate.m'') \newline
SmithOrderedForm[A] returns a list of three matrices
U, D, and V such that the m x n resampling matrix A
equals U D V where U (m x m) and V (n x n) are integer matrices
with a determinant of 1 and D is a diagonal matrix
of integer components such that det(D) = det(A).
The components along the diagonal of D are sorted by absolute value.
The diagonal elements are positive except for possibly the
last one whose sign will be the sign of det(A).
Note that this factorization is unique if none of the diagonal
elements are equal in absolute value.
Also note that the starting point is the result of the Smith
Normal Form decomposition.
Like SmithNormalForm, SmithOrderedForm supports a Dialogue option.
If True or All, SmithNormalForm will show immediate steps.
See also SmithNormalForm and SmithReducedForm.
\item {\tt SmithReducedForm} (in ``Multirate.m'') \newline
SmithReducedForm[A] returns a list of three matrices
U, D, and V such that the m x n resampling matrix A
equals U D V where U (m x m) and V (n x n) are integer matrices
with a determinant of +1 or -1 and D is a diagonal matrix
of positive integers such that $|$det(D)$|$ = $|$det(A)$|$.
Each component down the diagonal is a factor of the next one.
As a result, the diagonal elements are sorted down the diagonal.
The factorization is not unique.
Note that the starting point for this algorithm is the Smith
Ordered Form.
Like SmithOrderedForm, SmithReducedForm supports a Dialogue option.
If True or All, SmithNormalForm will show immediate steps.
See also SmithNormalForm and SmithOrderedForm.
\item {\tt Stable} (in ``TransSupport.m'') \newline
Stable[transexpr] returns True if the transform transexpr
represents a stable time-domain signal.
\item {\tt Start} (in ``DFT.m'') \newline
Start is a data-tag for the DFT.
\item {\tt Step} (in ``SigProc.m'') \newline
Step[n] is the unit step function which is 1 for n $>$= 0
and 0 otherwise.
It is commonly used for discrete n.
This function differs from CStep only at the origin.
\item {\tt StripPackage} (in ``SupCode.m'') \newline
StripPackage[symbol] returns the symbol (as a string) after its
context has been removed.
\item {\tt SubDataTypeQ} (in ``DataType.m'') \newline
SubDataTypeQ[expression, datatype] returns True if the data type
of expression could be coerced to datatype.
For example, SubDataTypeQ[5, Rational] is True, but
SubDataTypeQ[5.0, Rational] is False.
\item {\tt SubT} (in ``TransSupport.m'') \newline
SubT[transq, t1, t2] subtracts the transforms t2 from t1 and
determines the new region of convergence. The resulting transform
is returned as a list. SubT[transq, t1, t2, lowerlimit]
uses lowerlimit as the lower limit on the region of convergence
values when combining ROC's (default is 0).
\item {\tt SubTree} (in ``Tree.m'') \newline
SubTree[tree, head] returns the subtree with root head.
\item {\tt SubsetQ} (in ``SupCode.m'') \newline
SubsetQ[set1, set2, set3, ...] returns True if set1 is a subset
of set2 and set2 is a subset of set3, etc.
\item {\tt SubstituteForT} (in ``TransSupport.m'') \newline
SubstituteForT[transq, t, s, news] substitutes news at every
occurrence of s in the transform t. The resulting transform
is returned as a list.
\item {\tt Summation} (in ``SigProc.m'') \newline
Summation[i][f], Summation[i, iend][f], and
Summation[i, istart, iend, inc][f] represents the summation of f
with respect to variable i: i = (istart) to (iend) step (inc).
The Summation operator is an abstraction of Mathematica's Sum object.
Applying the object TheFunction to a Summation operator will invoke
the Sum object if istart, iend, and inc are numbers.
\item {\tt SymbolDataType} (in ``DataType.m'') \newline
SymbolDataType[symbol] returns the data type associated with
symbol or AllDataTypes if none exists.
\item {\tt SymbolDataTypeQ} (in ``DataType.m'') \newline
SymbolDataTypeQ[symbol, data-type] returns True if the symbol
is associated with the data type data-type.
Note that if a symbol is associated with Real,
then it is also associated with Integer and Rational as well.
\item {\tt TableLookup} (in ``SupCode.m'') \newline
TableLookup[index, hlist, len, val] returns hlist[[index]]
if index is between 1 and len, inclusive; otherwise, val is
returned.
\item {\tt TheFunction} (in ``SigProc.m'') \newline
TheFunction[object] returns the mathematical function embedded
in object.
For list and transform objects, this function returns
the first element after the head of the object; otherwise, the
contents of the slot TheFunction are returned.
For signal processing operations,
the equivalent mathematical operation is returned.
\item {\tt Third} (in ``SupCode.m'') \newline
Third[list] returns the third element of list.
\item {\tt ToCollection} (in ``SupCode.m'') \newline
ToCollection[expr] strips the head off of arg and returns
the argument of expr as a collection.
ToCollection returns an object that is a sequence,
which is represented in Mathematica 1.2 as (a1, a2, ...)
and in Mathematica 2.0 as Sequence[a1, a2, ...].
So, it provides a unified way of generating collections (sequences).
\item {\tt ToContinuous} (in ``SigProc.m'') \newline
ToContinuous[expr] replaces any discrete operator or signal
in expr with its continuous equivalent.
\item {\tt ToDiscrete} (in ``SigProc.m'') \newline
ToDiscrete[expr] replaces any continuous operator or signal
in expr with its discrete equivalent.
\item {\tt ToList} (in ``SupCode.m'') \newline
ToList[arg] returns arg if arg is a list.
Otherwise, List[arg] is returned.
ToList[arg1, arg2, ...] returns List[arg1, arg2, ...].
\item {\tt Transform} (in ``ROC.m'') \newline
Transform[transform, rminus, rplus] represents a transform.
Transform is also a tag for exporting errors messages like
Transform::twosided. This object is used exclusively by the
various transform rule bases.
\item {\tt TransformFixUp} (in ``TransSupport.m'') \newline
TransformFixUp[transform, options, time var, transform var,
transform head, triplet flag, transform name, lower, upper]
attempts to resolve incomplete transforms according to the
transform pairs provided by the user via the TransformLookup option.
If the transform is a triplet of information (funct, Rminus, Rplus),
e.g. the forward z- and Laplace transforms, then triplet flag is True
and the lower and upper arguments are used for the second and
third fields of the triplet.
\item {\tt TransformLookup} (in ``TransSupport.m'') \newline
TransformLookup is an option for the transform rule bases.
It allows the user to specify a list of transform pairs to augment
those that already exist in the transform rule bases.
For example, ZTransform[ Shift[L, n][x[n]], n, z,
TransformLookup -$>$ \{ x[n] :$>$ X[z] \} ].
This example allows the user to work x[n] without every defining it.
The multidimensional case is more tricky:
ZTransform[ x[n1, n2], n, z, TransformLookup -$>$
\{ x[n1, n2] :$>$ X[z1, n2], X[z1, n2] :$>$ X[z1, z2] \} ].
For the z- and Laplace transform rule bases, one can also specify
a region of convergence associated with the transform pairs.
\item {\tt UnAssociateDataType} (in ``DataType.m'') \newline
UnAssociateDataType[symbol] removes any association of that
that symbol with any data type.
UnAssociateDataType[symbol, datatype] removes the association
of symbol with datatype if one exists.
The function returns symbol.
See also AssociateDataType.
\item {\tt Unit} (in ``SigProc.m'') \newline
Unit[n][t] is the nth order continuous unit function in t.
Unit[0][t] is the Dirac delta function (see Delta).
Unit[-1][t] is the continuous step function (see CStep).
\item {\tt UnprotectIt} (in ``SupCode.m'') \newline
UnprotectIt[expr] evaluates expr.
If it evaluates to a symbol,
write protection will be removed for that symbol.
\item {\tt Upsample} (in ``SigProc.m'') \newline
Upsample[k,n][f] represents the upsampling operation on f,
which is either an expression of n or a squence (list) of values.
Upsampling inserts k-1 zeroes between every two samples.
In N dimensions, n is a list of N indices and k is an N x N matrix.
\item {\tt UpsampleFactor} (in ``SigProc.m'') \newline
UpsampleFactor[f, n] returns the upsampling index.
If this routine returns 1, then no upsampling has occurred;
if it returns 0, then f is constant with respect to n.
\item {\tt UpsampleSequence} (in ``SigProc.m'') \newline
UpsampleSequence[seq,m,fill] inserts m-1 fill values between
every two elements of seq.
\item {\tt UpsampledFunction} (in ``SigProc.m'') \newline
UpsampledFunction[m, fill, n, upf] represents the upsampling of f.
In one-dimension, the upsampled form of f, upf,
is obtained by evaluating n -$>$ n / m.
\item {\tt ValidIntervalQ} (in ``Convolution.m'') \newline
ValidIntervalQ[i] takes an F-interval i and
returns True if it is a meaningful representation of an interval
in either the domain specified by the Domain option or the
default domain \$ConvolutionDomain if no Domain option is present.
Otherwise, it returns False.
\item {\tt VariableQ} (in ``SupCode.m'') \newline
VariableQ[x] returns True if x is a symbol that
(1) does not have a numerical value associated with it and
(2) does not have its Constant attribute enabled.
Pi fails the first test, so it is not considered a variable.
A variable can also have the form of C[n] where n is an integer
and C is a symbol whose Constant attribute is enabled.
\item {\tt WithinROC} (in ``ROC.m'') \newline
WithinROC[rm1,rp1,rm2,rp2] returns True if the interval [rm1,rp1]
is a subset of the interval [rm2,rp2].
\item {\tt Z} (in ``SigProc.m'') \newline
Z[n, z] is the forward z-transform operator.
Applying TheFunction to the Z operator will invoke the z-transform
rule base ZTransform if loaded.
\item {\tt ZForm} (in ``ZSupport.m'') \newline
ZForm[x] return True if the data packet x is tagged with
either List or Transform and contains three elements.
\item {\tt ZSolve} (in ``ZSolve.m'') \newline
ZSolve[ diffequ == drivingfun, y[n] ] solves the difference
equation diffequ = drivingfun, where diffequ is a linear constant
coefficient difference equation and drivingfun is the driving
function (a function of n).
Thus, diffequ has the form a0 y[n] + a1 y[n - 1] + ....
By using options, one can specify initial values; e.g.,
ZSolve[ y[n] + 3/2 y[n-1] + 1/2 y[n-2] == (1/4)\verb:^:n Step[n],
y[n], y[-1] -$>$ 4, y[-2] -$>$ 10 ].
A difference equations of N terms needs N-1 initial values.
All unspecified initial values are considered to be zero.
Right-sided and left-sided solutions are possible.
ZSolve can justify its answers.
\item {\tt ZTransData} (in ``ROC.m'') \newline
ZTransData is a data tag for a valid z-transform object.
\item {\tt ZTransform} (in ``ZTransform.m'') \newline
ZTransform[e,n] or ZTransform[e,n,z] gives the z-transform of
the expression e, which is a function of n, by returning an object
of three slots which is tagged by ZTransData:
$<$z-transform$>$, $<$rminus$>$, $<$rplus$>$, and $<$z-variables$>$.
The Region of Convergence (ROC) is $<$rminus$>$ $<$ $|$z$|$ $<$ $<$rplus$>$.
Note that the returned ROC is either the actual ROC or a subset
of the actual ROC.
In two dimensions, ZTransform[e, \{n1, n2\}, \{z1, z2\}], is the same as
ZTransform [ ZTransform [e, n1, z1], n2, z2 ].
This notation extends naturally to higher dimensions.
\item {\tt ZTransformQ} (in ``ZSupport.m'') \newline
ZTransformQ[x] returns True if the datum x is of the form
ZTransData[X, rm, rp, z], where X is the z-transform, rm is the
Rminus component of the region of convergence, rp is the
Rplus component of the region of convergence, and z is
the variable(s) in the z-transform.
\item {\tt ZUpsampledQ} (in ``ZSupport.m'') \newline
ZUpsampledQ[f, n] returns True if the sequence f, as a function
of n, has been upsampled. See UpsampleFactor.
\item {\tt ZVariables} (in ``ROC.m'') \newline
ZVariables is a data tag for the variables in a z-transform object.
When applied to an object x containing z-transform information,
ZVariables[x] returns the z-variables contained in the z-transform.
For example, if x is a z-transform object of the form
ZTransData[ zexpr, Rminus[r-], Rplus[r+], ZVariables[z] ], then
ZVariables would return z.
\item {\tt ZeroQ} (in ``SupCode.m'') \newline
ZeroQ[x] returns True if x is 0 or 0.0
\item {\tt \$ConvolutionDomain} (in ``Convolution.m'') \newline
\$ConvolutionDomain is the default domain for all of the convolution
routines in the signal processing packages.
Use SetConvolutionDomain to reset its value.
\end{enumerate}
\end{document}