\documentstyle[11pt]{article}
\setlength{\oddsidemargin}{0.0in}
\setlength{\textwidth}{6.5in}
\setlength{\textheight}{8.25in}
\setlength{\topmargin}{-0.25in}
\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 \$ConvolutionDomain} (in ``Convolution.m'') \newline
\$ConvolutionDomain is the default domain for all of the routines
in the Convolution package (except for DTPiecewiseConvolution and
CTPiecewiseConvolution which imply a domain).
Use SetConvolutionDomain to reset its value.
\item {\tt \$DeltaFunctionScaling} (in ``SigProc.m'') \newline
The variable \$DeltaFunctionScaling dictates how to scale the height
of Delta functions for the purposes of plotting: None or Scaled.
\item {\tt \$PtolemyProlog} (in ``Ptolemy.m'') \newline
\$PtolemyProlog is a global variable containing the definitions
to make the generated Ptolemy code work properly.
The default value will find the file ``headerX.X.pt'' on Mathematica's
path, read it in, and write it out,
where X.X is \$PtolemyVersion.
This is useful if you are running the Ptolemy interpreter on
another file system.
Otherwise, you can set this value to
%%%%
\begin{verbatim}
StringJoin[ "(load \"",
FindFile["SignalProcessing`ObjectOriented`headerX.X.pt", $Path ],
"\")" ]
\end{verbatim}
%%%%
where X.X is the version of Ptolemy you are using,
which will cause Ptolemy to load the header
as the first step in running the simulation.
\item {\tt \$PtolemyVersion} (in ``Ptolemy.m'') \newline
\$PtolemyVersion indicates the current version of Ptolemy being used.
Currently, only version 0.3 of Ptolemy is supported.
\item {\tt ADDITIVE} (in ``System.m'') \newline
ADDITIVE is a system property.
An operator T is additive if T[x + y] = T[x] + T[y] for all x, y.
It also serves as a function.
ADDITIVE[system] returns True if the operator system is additive.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt AKindOf} (in ``Slot.m'') \newline
AKindOf is a slot that describes the class to which
the object belongs.
\item {\tt ASPAnalyze} (in ``ASPAnalyze.m'') \newline
ASPAnalyze[f, t], ASPAnalyze[f, \{t, start, end\}], and
ASPAnalyze[f, t, start, end] will plot f as a one-dimensional,
continuous-time function of t (real part of f will be shown as solid
lines, the imaginary part as dashed lines).
The routine will also print the strip of convergence, indicate
stability criteria, display the pole-zero diagram, and
plot the magnitude and phase responses.
The two-dimensional version becomes ASPAnalyze[f, \{t1, t2\}],
ASPAnalyze[f, \{t1, start1, end1\}, \{t2, start2, end2\} ], or
ASPAnalyze[f, \{t1, t2\}, \{start1, start2\}, \{end1, end2\} ].
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 ASSOCIATIVE} (in ``System.m'') \newline
ASSOCIATIVE is a system property.
It also serves as a function.
ASSOCIATIVE[system] returns True if the system is associative.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt AddChildToTree} (in ``Tree.m'') \newline
AddChildToTree[tree, parent, newchild] adds newchild under
every parent in tree.
\item {\tt AddSlot} (in ``Slot.m'') \newline
AddSlot[object, writeflag, slot, initvalue] adds the slot to
object, where object (a symbol assigned to the object's value)
is mutated; initvalue is the initial value assigned to this
new slot and writeflag is True if the slot can be overwritten.
The object is returned if the slot slot already exists.
Note that initvalue can be a collection of values like 1,2,3.
\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 region of convergence values when combining ROC's (default is 0).
\item {\tt AdditiveCosts} (in ``CostFunctions.m'') \newline
AdditiveCosts[ oper[p1, p2, ..., pn][sig1, sig2, ..., sign ] ]
returns the number of additions needed to implement the
operator oper (having parameters p1, p2, ..., pn) in terms
of the sampling rate of the input signals sig1, sig2, ..., sign.
\item {\tt Adjoin} (in ``Lisp.m'') \newline
Adjoin[item, list] prepends item to list if it is not already
in the list.
\item {\tt AlgorithmCostFunction} (in ``CostFunctions.m'') \newline
AlgorithmCostFunction[ expr, \{w1, w2, ..., wn\}, \{f1, f2, ..., fn\} ]
computes the cost of expr as a weighted sum of cost functions, i.e.
sum (wi fi) over i.
The cost functions should be able to measure the cost of a
general expression.
\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.
It is always rewritten in terms of the Periodic operator.
\item {\tt AllEquivalentForms} (in ``Heuristics.m'') \newline
AllEquivalentForms[expr, rules] returns a list of all possible
ways to rewrite expr according the list of rules.
The Max options specifies an upper limit on the number of rewritten
forms returned.
\item {\tt AllSubsets} (in ``SupCode.m'') \newline
AllSubsets[set] returns a list of all subsets of set,
including the null set \{\}.
The original set must be a list.
\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 a filter expression
containing one or more of a gain term, a CFIR section, and a
CIIR section.
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.
The Bessel filter design procedure, however, only uses the order
and the cutoff-frequency and ignores the other arguments.
See also FilterParameters and FilterOrder.
\item {\tt AppendSlot} (in ``Slot.m'') \newline
AppendSlot[object, slot, appendfun, addvalue] will set the
value of the slot slot in object to the value returned by
calling appendfun with two arguments: the old value of the
slot and addvalue.
Note that object is an unevaluated symbol and that addvalue
can be a collection of values like 1,2,3.
\item {\tt ApplyHomogeneityRule} (in ``TransSupport.m'') \newline
ApplyHomogeneityRule[fun, head, var, rest] applies the homogeneity
rule (factor out constants) to function fun for the transform
represented by head.
\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 ArraySignal} (in ``Signal.m'') \newline
ArraySignal[oldsig, start, end] returns a new signal which has
slots Start and End equal to start and end, respectively, and is
array-based (Implementation slot is Array).
\item {\tt ArraySignalQ} (in ``Signal.m'') \newline
ArraySignalQ[signal] returns True if the signal is array-based,
which means that all signal values are computed at one time and
stored.
\item {\tt Arrow2D} (in ``SupCode.m'') \newline
Arrow2D[tail, plotwidth, plotheight] returns a graphics object
that is an arrow starting at tail, pointing upwards, of
length plotheight.
The length of the tail and the direction of the arrow are controlled
by an optional fourth parameter.
\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 Assuming} (in ``SupCode.m'') \newline
Assuming[condition] keeps track of assumptions made during
a calculation.
Assuming[All] gives all of the current assumptions.
Assuming[condition, True] prints the condition if it is not True.
Assuming[] removes all current assumptions.
\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 ``LatticeTheory.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).
In this case, BezoutNumbers simply calls ExtendedGCD.
For the collection of integers a1, a2, ..., an,
BezoutNumbers[a1, a2, ..., an] returns a list of integer coefficients
k1, k2, ..., kn such that k1 a1 + k2 a2 + ... + kn an = d,
where d is the greatest common divisor of a1, a2, ..., an.
The solutions of the Bezout identity are periodic.
This routine will always return those solutions smallest in absolute
value.
See also ExtendedGCD.
\item {\tt BilinearTransformation} (in ``FilterSupport.m'') \newline
BilinearTransformation[omega, w, k] maps a continuous frequency
omega (in rad/sec) to a discrete frequency w (in rad) in the interval
(0, Pi) by the relationship omega = k Tan[w/2].
BilinearTransformation 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.
\item {\tt BranchOperation} (in ``Ptolemy.m'') \newline
BranchOperation[token, simpleOper, refs] represents one simple
operation simpleOper in the computation of a larger algorithm
with the output(s) referenced by the symbol token.
The larger algorithm uses the output n times.
BranchOperation[token, simpleOper, n, Constant] indicates that the
token is an alias for a constant computed according to simpleOper.
This object is displayed as token := simpleOper.
See ExpressionToBranchOperations.
\item {\tt ButLast} (in ``Lisp.m'') \newline
ButLast[list] and ButLast[list, n] returns list but drops last
n elements (by default, n = 1).
\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 an all-pole analog filter
with gain 1 and DC gain 1/a0.
The terms a1, a2, ... are the feedback coefficients.
The Laplace transform of such an expression is
1 / ( a0 + a1 s + a2 s\verb:^:2 + ... ).
Such filters can alternatively be specified by their poles via
CIIR[t, Roots -$>$ \{-1, -2, -3\}] which yields the object
CIIR[t, \{6., 11., 6., 1\}, Roots -$>$ \{-1, -2, -3\}].
CIIR is also an operator whose default input is a Dirac delta.
An alternate input h can be specified by
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.
\item {\tt COMMUTATIVE} (in ``System.m'') \newline
COMMUTATIVE is a system property.
It also serves as a function.
COMMUTATIVE[system] returns True if the system is commutative.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt CONTINUOUS} (in ``System.m'') \newline
CONTINUOUS is a system property.
It also serves as a function.
CONTINUOUS[system] returns True if the operator system only takes
CONTINUOUS systems as arguments.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\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.
Under Mathematica 2.1 and higher, CStep is defined as UnitStep,
but UnitStep will always be displayed as CStep so the change
should be transparent to the user.
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.
The time variable is t, and the frequency variable is w.
In multiple dimensions, t and w become lists of time and
frequency variables, respectively.
\item {\tt CTPiecewiseConvolution} (in ``Convolution.m'') \newline
CTPiecewiseConvolution[h, x, t] carries out the one-dimensional,
continuous-time piecewise convolution of h and x with respect to t.
See PiecewiseConvolution for valid representation of h and x.
Using F-interval notation \{function, left end point, right end point\},
a Dirac delta is meant when function = Area[$<$area$>$]
(where $<$area$>$ equals the area of under the impulse function) and
left end point = right end point (the location of the impulse).
A Dialogue option of True or All will cause the graphs for an
animation to be generated in which h is flipped in the variable t
and then slid across x.
See also PiecewiseConvolution.
\item {\tt CenterOfSymmetry} (in ``Signal.m'') \newline
CenterOfSymmetry[signal] returns the center-of-symmetry of the
signal.
\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
written as ChebyshevT[n, s] in Mathematica.
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 written as ChebyshevT[n, s] in Mathematica.
The magnitude response of the passband
monotonically decreases with respect to frequency.
\item {\tt CheckSeparability} (in ``System.m'') \newline
CheckSeparability[ op[parameters] ] checks returns a list of the
variables in which op[parameters] is separable.
CheckSeparability[ op[parameters], varlist ] checks to see in
which of the variables in varlist the operator is separable.
\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.
CirclePS makes use of the Circle primitive.
\item {\tt CircularShift} (in ``SigProc.m'') \newline
CircularShift[n0, N, n] represents the circular shifting of a
sequence of length N in index variable n by n0.
That is, the sequence is treated as a ring buffer of length N
so each sample at index n is shifted to the right by
(n + n0) mod N places.
See also the SPP function Shift and the Mathematica function
RotateRight.
\item {\tt ClearQueue} (in ``StackQueue.m'') \newline
ClearQueue[q] sets q to be an empty queue.
\item {\tt ClearStack} (in ``StackQueue.m'') \newline
ClearStack[s] sets s to be an empty stack.
\item {\tt ColumnHermiteForm} (in ``LatticeTheory.m'') \newline
ColumnHermiteForm[F] returns \{X, H\} where X is the m x m regular
unimodular matrix that puts the m x n integer matrix F into upper
triangular (column Hermite) form H (which is m x n).
That is, X . F = H.
\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 CommutableResamplingMatricesQ} (in ``LatticeTheory.m'') \newline
CommutableResamplingMatricesQ[downsamplingmat, upsamplingmat]
returns True if the two resampling operations are commutable.
\item {\tt ComplexQ} (in ``Lisp.m'') \newline
ComplexQ[z] returns True if z is a complex number, False otherwise.
\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 zlist.
That is, zlist is mapped through ComplexTo2DCoord.
\item {\tt ComputableSignalQ} (in ``Signal.m'') \newline
ComputableSignalQ[signal] returns True if computational methods
like Fetch are supported for the signal.
This is true if the signal has an Implementation slot.
\item {\tt ComputePerOutputSamplingRate} (in ``CostFunctions.m'') \newline
ComputePerOutputSamplingRate[expr, fun1, fun2, vars] in 1-D simply
returns the sampling rate for expr.
In m-D, this function first applies fun1 to each column of the
sampling matrix for expr in terms of variables vars and
then applies fun1 to the resulting vector.
\item {\tt ConjT} (in ``TransSupport.m'') \newline
ConjT[transq, X(s), s] implements T\{ x*(t) \} --$>$ X*(s*),
where X(s) is the transform of x(t).
\item {\tt Cons} (in ``Lisp.m'') \newline
Cons[x, list] prepends x to the list.
Cons[x, y] returns \{x, y\} if y is not a list.
\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 if it is a number or
if 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.
ConstantQ[x, c1, c2, ...] and ConstantQ[x, \{c1, c2, ...\}]
analyze the expression x assuming that c1, c2, ... 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
FormulaToPiecewise[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.
The old name for this function is ConvertFromList.
\item {\tt ConvertToList} (in ``Convolution.m'') \newline
PiecewiseToFormula[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.
The old name for this function is ConvertToList.
\item {\tt ConvexPolygonIntersection} (in ``Polygons.m'') \newline
ConvexPolygonIntersection[ p1, p2, ... ] returns the intersection
of polygons p1, p2, ...
The algorithm exhaustive enumerates all line segments connecting
the vertices in the two polygons.
This function returns an empty list if there are no intersections.
\item {\tt ConvolutionOutputForm} (in ``Convolution.m'') \newline
ConvolutionOutputForm is an option for CTPiecewiseConvolution
PiecewiseConvolution, and DTPiecewiseConvolution.
It can take a value of Automatic, Formula, or Piecewise.
If the option is set to Automatic, then the output will depend on
the form of the inputs: if either input was specified as a
formula (or expression), then the output will also be a formula;
otherwise, the output will be a list of F-intervals.
If the option is set to Piecewise, the output will be a list of
F-intervals no matter the way the input is specified.
If it is set to Formula, the output will be an expression
no matter the input form.
\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 CostRange} (in ``CostFunctions.m'') \newline
symbol/: CostRange[symbol] = range assigns a range of values
to the symbol.
You can remove the definition by evaluating
symbol/: CostRange[symbol] = . .
\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).
\item {\tt DFTData} (in ``DFT.m'') \newline
DFTData is a data tag for the symbolic DFT.
\item {\tt DFTransform} (in ``DFT.m'') \newline
DFTransform[f, N, n, k] returns the DFT of sequence f which is
a function of the time index n.
Sequence f is defined over the interval n = 0 to n = N - 1.
Only the first two arguments are required
DFTransform calls DTFTransform when it cannot determine the DFT.
\item {\tt DISCRETE} (in ``System.m'') \newline
DISCRETE is a system property.
It also serves as a function.
DISCRETE[system] returns True if the system only accepts
DISCRETE signals as arguments.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\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).
\item {\tt DTFTData} (in ``DTFT.m'') \newline
DTFTData is the data tag for the discrete-time Fourier transform.
\item {\tt DTFTransform} (in ``DTFT.m'') \newline
DTFTransform[f, n, w] returns the discrete-time Fourier transform
of the input function f with respect to n.
The result is a function in w that is periodic with period 2 Pi
in w.
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.
For the multidimensional DTFT, n and w becomes lists.
Also note that only the first two arguments are required.
\item {\tt DTPiecewiseConvolution} (in ``Convolution.m'') \newline
DTPiecewiseConvolution[h, x, n] carries out the one-dimensional,
discrete-time piecewise convolution of h and x with respect to n.
See PiecewiseConvolution for the valid representations of h and x.
Using F-interval notation \{function, left end point, right end point\},
an impulse (Kronecker delta) function is meant when
left end point = right end point (the location of the impulse)
and the strength of the impulse function is given by function.
A Dialogue option of True or All will cause the graphs for an
animation to be generated in which h is flipped in the variable n
and then slid across x.
Real-valued interval end points will be truncated to integers.
See also PiecewiseConvolution.
\item {\tt DefaultSlot} (in ``Slot.m'') \newline
DefaultSlot[object tag, slot, value] will set up the value as the
default for the slot in any object with a tag of object tag.
For example, to set up 0 as the default value for the slot
CurrentValue of a Signal, use DefaultSlot[Signal, CurrentValue, 0].
\item {\tt DefineObjectType} (in ``Slot.m'') \newline
DefineObjectType[object, parent object] clears the attributes
of object and sets the HoldRest attribute.
\item {\tt DefineSystem} (in ``System.m'') \newline
DefineSystem[operator, property1, property2, ...] will install
the operator as a system.
The properties property1, property2, ... are considered to be True
for the operator.
For example, if DefineSystem[Upsample[l, n], DISCRETE, LINEAR]
is evaluated, Upsample will be added to the list of system operators
SPsystems, and one of the four rules generated is
CONTINUOUS[Shift[l,n]] := True.
Note that CONTINUOUS[Shift] will have no meaning.
\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 DeleteSlot} (in ``Slot.m'') \newline
DeleteSlot[object, slot] removes the slot slot from object and
returns the new object.
Note that object is an unevaluated symbol.
\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.
Under Mathematica 2.1 and higher, Delta is defined as DiracDelta,
but DiracDelta will always be displayed as Delta so the change
should be transparent to the user.
It differs from the Kronecker delta function Impulse[t].
\item {\tt DeltaIntegrate} (in ``SigProc.m'') \newline
DeltaIntegrate[fun, \{x, xlower, xupper\}] and DeltaIntegrate[fun, x]
are special hooks for the built-in Integrate routine.
Under Mathematica 2.1, the rules in Calculus`DiracDelta`
take precedence over this function.
\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, tmin, tmax, ymin, ymax.
In the second case, either five or seven arguments are passed:
deltafuns, t, tmin, tmax, 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.
The variable \$DeltaFunctionScaling dictates how Delta functions
are scaled when plotted: None or Scaled.
\item {\tt Dequeue} (in ``StackQueue.m'') \newline
Dequeue[queue, element] removes element from the queue.
\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 DesignDecimationSystem} (in ``Decimation.m'') \newline
DesignDecimationSystem[Polygon[pointlist]] returns the decimation
system to resample the bandpass signal (which is a convex hull
represented by the polygon) at the Nyquist rate.
The complete decimation system consists of four parts in cascade:
modulator, upsampler, filter, and downsampler.
The modulator is defined as Exp[I shiftVector . timeIndices ].
This routine returns a list:
\{ shiftVector, upsampling matrix, downsampling matrix \}.
The Mod option controls the grid size and therefore the size
of the entries of the resampling matrices.
DesignDecimationSystem[ratmat] converts the rational resampling
matrix into a decimation system.
\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 DiagonalMatrixQ} (in ``LatticeTheory.m'') \newline
DiagonalMatrixQ[matrix] returns True if the matrix is diagonal,
and gives False otherwise.
\item {\tt Dialogue} (in ``SupCode.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, respectively.
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 the
intermediate calculations involved in taking the transform.
\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 normalized aliased sinc function.
which is defined as Sin[N w / 2] / ( N Sin [w / 2] ).
It is periodic in w with a period of 2 Pi for N odd and a
period of 4 Pi for N even.
Note that Dirichlet[N, 0] is 1.
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.
It takes two optional arguments: a line thickness (or plot style)
and a point thickness.
Each is a real value from 0 to 1 indicating a width that
is a fraction of the size of the entire graph.
\item {\tt DiscreteTimeSignalQ} (in ``Signal.m'') \newline
DiscreteTimeSignalQ[signal] returns True if the signal is
a discrete-time signal.
\item {\tt DistinctCMYKColors} (in ``Polygons.m'') \newline
DistinctCMYKColors[n] will generate a list of n distinct
cyan, magenta, yellow, and black colors.
\item {\tt DistinctCosetVectors} (in ``LatticeTheory.m'') \newline
DistinctCosetVectors[resmat] returns a sorted list of all of the
distinct coset vectors associated with the resampling matrix resmat.
DistinctCosetVectors[resmat, \{U, D, V\}] finds all of the
distinct coset vectors of resmat from its Smith Form U D V.
This is carried by finding the distinct coset vectors of the diagonal
matrix D, mapping them by U, and then taking each vector
modulo the resampling matrix resmat.
The returned coset vectors are not sorted.
\item {\tt DistinctRGBColors} (in ``Polygons.m'') \newline
DistinctRGBColors[n] will generate a list of n distinct
reg, green, and blue colors as distinct form one another as possible
but also with as much contrast to white and black as possible.
\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 DownsamplingAliasing} (in ``Decimation.m'') \newline
DownsamplingAliasing[M, polylist] graphically illustrates the effect
of downsampling by the integer matrix M on the frequency domain
of the input signal represented as the union of polygons expressed
as the list of polygons polylist.
The input and output frequency domains, although representing
different sampling grids, are both graphed in the fundamental
tile -Pi $<$ w1 $<$ Pi and -Pi $<$ w2 $<$ Pi.
The Dialogue option controls how much analysis will be performed:
False for none, True for some, and All for all.
\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[expr, n] returns the nth element of expr if n is an integer
or list of integers.
Element[expr, n1, n2, ..., nm] returns expr[[n1, n2,..., nm]] if
n1, n2, ... nm are integers.
Element also works if the indices can be rationalized to be integers,
so Element[\{1,2,3\}, 1.] returns 1.
\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 Elt} (in ``Lisp.m'') \newline
Elt[list, n] returns the nth element in the list
with n=0 indicating the first element.
\item {\tt EmptyQ} (in ``SupCode.m'') \newline
EmptyQ[packet] returns True the packet of data is empty.
\item {\tt EndBandwidth} (in ``Signal.m'') \newline
EndBandwidth[signal] retuns the end location of a signal's bandwidth.
In the case of signals that are not band-limited,
this function will return Infinity (the default).
\item {\tt Enqueue} (in ``StackQueue.m'') \newline
Enqueue[queue, element] adds element to the queue.
\item {\tt EuclidFactors} (in ``LatticeTheory.m'') \newline
EuclidFactors[k, p, q] gives the factors a and b such that
p a + q b == k for relatively prime p and q.
When p and q are integers, this routine searches over a set of
min($|$p$|$, $|$q$|$) integers.
When p and q are integer matrices, this routine searches over a
set of min($|$det(p)$|$, $|$det(q)$|$) integer vectors and the vector a
or b corresponding to the integer matrix with the smallest
determinant will always be a distinct coset of that matrix.
See also RelativelyPrime.
\item {\tt Every} (in ``Lisp.m'') \newline
Every[query, expr] returns True if every element of expr
satisfies the test query.
Every[query, expr, levelspec] returns True if every part of the
expression expr satisfies the test query.
\item {\tt ExpressionToBranchOperations} (in ``Ptolemy.m'') \newline
ExpressionToBranchOperations[expr] decomposes a nested Mathematica
expression (tree) into a list of simpler (branch) operations.
The full calling sequence is ExpressionToBranchOperations[expr,
pullConstants, gainflag, plusflag, a1, a2, ...].
If pullConstants is True, then this routine will combine constants
within a product (if gainflag is True) and a summation (if incflag
is True) into one constant term.
The arguments a1, a2, ... indicate symbols in expr to be treated
as constants (see ConstantQ).
Definitions of these constants are not included as branch operations
because their values are unknown.
See BranchOperation.
\item {\tt Extent1D} (in ``SigProc.m'') \newline
Extent1D[expression, var] returns an interval
\{lower-limit, upper-limit\} outside of which the function is zero.
This routine assumes that var is a real variable.
The routine returns None if the function is zero-valued for all var.
\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).
\item {\tt FVariables} (in ``DSupport.m'') \newline
FVariables is a data tag for the transform variables in a
Fourier transform.
\item {\tt FactorRationalResamplingMatrix} (in ``Decimation.m'') \newline
FactorRationalResamplingMatrix[ratmat] factors the non-singular
rational matrix into two matrix factors L\verb:^:-1 M where L and M are
both non-singular integer matrices.
\item {\tt Fetch} (in ``Signal.m'') \newline
Fetch[signal, index] returns the value of the signal at index,
where index can be a number (for one-dimensional signals) or a
list of numbers (for multidimensional signals). Fetch only
works for computable signals which are arrayed, pointwise, and
stream signals. Stream signals also have an associated method
called FetchNext. If the signal is arrayed and if any one of
the indices is an infinity, then the value of the signal's
OutOfDomainValue slot will be returned.
\item {\tt FetchArray} (in ``Signal.m'') \newline
FetchArray[array signal] ...
\item {\tt FetchNext} (in ``Signal.m'') \newline
FetchNext[stream signal] will return the next value in the stream
of data represented by stream signal.
\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 FindBoundingRegion} (in ``Decimation.m'') \newline
FindBoundingRegion[majorAxis, polygon] finds the smallest rectangle
enclosing the convex hull represented by polygon with the line
majorAxis as the rectangle's major axis.
\item {\tt FindFile} (in ``SupCode.m'') \newline
FindFile[ filename, dirlist ] looks at the directories in dirlist
to find the file filename.
The filename can be a context (i.e. one containing backquotes).
It returns \$Failed if it cannot find the file.
A common use of this function is FindFile[filename, \$Path].
\item {\tt FindMinimumRectangle} (in ``Decimation.m'') \newline
FindMinimumRectangle[ Polygon[pointlist] ] finds the rectangle of
minimum area that circumscribes the convex hull represented as a
polygon.
The rectangle, which may be rotated about an axis, is returned
as a polygon.
\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 rplus1 and rplus2.
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 Formula} (in ``Convolution.m'') \newline
Formula is an option for the piecewise convolution routines.
See ConvolutionOutputForm for more information.
\item {\tt FourierSimplify} (in ``DSupport.m'') \newline
FourierSimplify[x] applies exponential to trigonometric rewrite
rules to expression x.
\item {\tt FunctionToPtolemy} (in ``Ptolemy.m'') \newline
FunctionToPtolemy[head] converts a Mathematica function like Cos
to Ptolemy star.
\item {\tt GCLD} (in ``LatticeTheory.m'') \newline
GCLD[a, b] finds a greatest common left divisor of resampling
matrices a and b which is unique to within the product of
a regular unimodular matrix on the right.
It forms F = \{\{a, b\}, \{0, 0\}\} and solves the equation F . X = H
where X is a square regular unimodular matrix and H is the row
Hermite (lower-triangular) form of the rectangular matrix F.
Of the four submatrices of H, only H11 is non-zero.
The GCLD of a and b is H11.
This routine supports a Dialogue option.
See also LCLM, RowHermiteForm, and ResamplingMatrix.
\item {\tt GCRD} (in ``LatticeTheory.m'') \newline
GCRD[a, b] returns a greatest common right divisor of resampling
matrices a and b which is unique to within the product of
a regular unimodular matrix on the left.
It forms F = \{\{a, 0\}, \{b, 0\}\} and solves the equation X . F = H
where X is a square regular unimodular matrix and
H is the column Hermite (upper-triangular) form of
the rectangular matrix F.
Of the four submatrices of H, only H11 is non-zero.
H11 is the GCRD.
This routine supports a Dialogue option.
See also LCRM, ColumnHermiteForm, and ResamplingMatrix.
\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 GetAllShiftFactors} (in ``SupCode.m'') \newline
GetAllShiftFactors[expr, x] returns a list containing all
shift factors in the variable x.
The expression is traversed as is using a depth-first search.
For example, GetAllShiftFactors[ (2 s + 2 b + c) Exp[s + b + Pi], s]
returns \{ b + Pi, (2 b + c)/2 \}.
\item {\tt GetArgs} (in ``SupCode.m'') \newline
GetArgs[function] returns the argument(s) of the function.
For example, GetArgs[ Bogus[1,2,3] ] would return 1,2,3.
If the programmer only wishes to replace the head of a function
with another, then use Apply instead of GetArgs.
This function is similar to ToCollection.
\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, ..., parn] ]
returns the last parameter, parn.
\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).
When GetRootList cannot find a set of roots, it will search for
numeric roots.
\item {\tt GetShiftFactor} (in ``SupCode.m'') \newline
GetShiftFactor[expr, x] returns a list containing the common
shift factor in the variable x and a normalized version of expr.
For example, GetShiftFactor[ (2 s + 2 b + c) Exp[s + b + Pi], s]
returns \{b, 2 Exp[Pi + b + s] (b + c/2 + s)\}.
\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 HOMOGENEOUS} (in ``System.m'') \newline
HOMOGENEOUS is a system property.
An operator T is homogeneous if T[a x] = a T[x] if a is a scalar.
It also serves as a function.
HOMOGENEOUS[system] returns True if the system is homogeneous.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\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 HasSlotQ} (in ``Slot.m'') \newline
HasSlotQ[object, slot] returns True if the slot slot exists
in object.
\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
negated 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 IIRCoefficients} (in ``Signal.m'') \newline
IIRCoefficients is a special slot for infinite-impulse response
digital filters.
It simply contains a list of feedback coefficients.
\item {\tt IIRFilter} (in ``Signal.m'') \newline
IIRFilter[p,a0,a][x] calculates the output of the IIR filter
at discrete time n, where the input at time n is x. The feedback
coefficients are in the a vector and each is scaled by a0. The
list p is a table of the last L outputs, where L is the number of
feedback coefficients.
\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 IIRPostUpdate} (in ``Signal.m'') \newline
IIRPostUpdate is a special method just for IIR signals.
\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 ImpulseTrain} (in ``LatticeTheory.m'') \newline
ImpulseTrain[D, n] represents an infinite collection of
Kronecker impulse functions.
In one-dimension, D and n are integers.
The multidimensional separable form is when both D and n are
integer vectors of the same length.
In the non-separable case, D is a resampling matrix and
n is an integer vector.
This function gives 1 whenever D\verb:^:-1 n is an integer (vector), and
gives 0 otherwise.
See also ResamplingMatrix and Impulse.
\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 ``LatticeTheory.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 IndependentVariable} (in ``Signal.m'') \newline
IndependentVariable[signal] returns the independent variable(s)
involved in the signal's (functional) definition.
\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 ``SupCode.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 InputPortName} (in ``Ptolemy.m'') \newline
InputPortName[op] indicates the name of the signal input port
in Ptolemy for the operator op.
By default, the function returns input .
\item {\tt InsidePolygonQ} (in ``Polygons.m'') \newline
InsidePolygonQ[ Polygon[vertices], Point[coordinates] ] returns
true if the point is inside the polygon, and False otherwise.
A third argument is a flag, which defaults to False, indicating
what to return if the point lies on an edge of the polygon.
\item {\tt IntegerVectorQ} (in ``LatticeTheory.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 Intern} (in ``Lisp.m'') \newline
Intern[string] and Intern[string, package] creates a new
symbol with the same name as string in the package given
(the current package is used in no package is given).
\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 interval, and
gives False otherwise.
An interval has the form \{f, t1, t2\} such that none of f, t1, or t2
are lists.
See also ValidIntervalQ.
\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 variable w and time
variable t.
In multiple dimensions, w and t become lists of frequency and
time variables, respectively.
\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).
\item {\tt InvDFTransform} (in ``DFT.m'') \newline
InvDFTransform[f, N, k, n] takes the inverse DFT of sequence f
which is a function of n that is defined over the interval
n = 0 to n = N - 1.
Only the first two arguments are required.
InvDFTransform calls InvDTFTransform as a last resort.
\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.
\item {\tt InvDTFTransform} (in ``DTFT.m'') \newline
InvDTFTransform[f, w, n] returns the inverse discrete-time Fourier
transform with respect to w of the f.
The function f is assumed to be periodic in w.
The first two arguments are required.
For the multidimensional version, w and n are lists.
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.
\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.
\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+.
In multiple dimensions, s and t become lists of Laplace and time
variables, respectively.
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.
\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.
This routine returns signal processing expressions.
Convert them to mathematical formulas by using TheFunction.
The inverse transform of large expressions will be found much faster
if automatic simplification is disabled by using the option
Simplify -$>$ False.
\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 KVariables} (in ``DFT.m'') \newline
KVariables is a slot in the DFTData data structure which indicates
the DFT frequency variables.
\item {\tt KeepNormalized} (in ``ZSupport.m'') \newline
KeepNormalized[zexpr, fun, z, args] keeps the z-transform
expression zexpr in negative powers of z after the function
fun is applied to zexpr and args as fun[zexpr, args].
\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.
\item {\tt LCLM} (in ``LatticeTheory.m'') \newline
LCLM[a, b] returns a least common left multiple of resampling
matrices a and b which is unique to within the product of
a regular unimodular matrix on the left.
It forms F = \{\{a, 0\}, \{b, 0\}\} and solves the equation X . F = H
where X is a regular unimodular matrix and H is the column Hermite
(upper-triangular) form of the rectangular matrix F.
Of the four submatrices of H, only H11 is non-zero.
The LCLM of a and b is (X21 . a) = -(X22 . b).
This routine supports a Dialogue option.
See also GCRD, ColumnHermiteForm, and ResamplingMatrix.
\item {\tt LCRM} (in ``LatticeTheory.m'') \newline
LCRM[a, b] finds a least common right multiple of resampling
matrices a and b which is unique to within the product of
a regular unimodular matrix on the right.
It forms F = \{\{a, b\}, \{0, 0\}\} and solves the equation F . X = H
where X is a regular unimodular matrix and H is the row Hermite
(lower-triangular) form of the rectangular matrix F.
Of the four submatrices of H, only H11 is non-zero.
The LCRM of a and b is (a . X12) = -(b . X22).
This routine supports a Dialogue option.
See also GCLD, RowHermiteForm, and ResamplingMatrix.
\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 LINEAR} (in ``System.m'') \newline
LINEAR is a system property.
A system is linear if it is both HOMOGENEOUS and ADDITIVE.
It also serves as a function.
LINEAR[system] returns True if the operator system is linear.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt LINEARPHASE} (in ``System.m'') \newline
LINEARPHASE is a system property.
A system exhibits linear phase if the phase component of its
frequency response is an affine function of the frequency.
It also serves a a function.
LINEARPHASE[system] returns True if the system is memoryless.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\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 slot in a Laplace transform object indicating
the Laplace variables used in the transformation.
\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 either case, the impulse can be removed by setting n1=n2 or t1=t2,
which yields a one-dimensional function.
The resulting 1-D 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 ``Lisp.m'') \newline
ListQ[expr] gives True if expr is a List, and False otherwise.
\item {\tt ListReduce} (in ``Lisp.m'') \newline
ListReduce[f, list], ListReduce[f, list, fromEndFlag], and
ListReduce[f, list, fromEndFlag, initialValue] mimic the Lisp
reduce routine.
For example, ListReduce[Plus, \{1, 2, 3, 4\}, False, 0] gives
(((1 + 2) + 3) + 4) or 10.
Mathematica's Fold command is used to implement ListReduce.
\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 MEMORYLESS} (in ``System.m'') \newline
MEMORYLESS is a system property.
A system is memoryless if each output corresponding to a given input
only depends on the input (and not past values of the input).
It also serves a a function.
MEMORYLESS[system] returns True if the system is memoryless.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
A MEMORYLESS system with a single input is also SHIFTINVARIANT.
See also DefineSystem and SystemQ.
\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 magnitude plot.
\item {\tt MakeContinuousSignal} (in ``Signal.m'') \newline
MakeContinuousSignal[] returns a signal object with the slot
CONTINUOUS set to True.
\item {\tt MakeDigitalSignal} (in ``Signal.m'') \newline
MakeDigitalSignal[] returns a signal object with the slot
DISCRETE set to True.
\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 MakeObject} (in ``Slot.m'') \newline
MakeObject[object] returns a packet of data tagged with object.
Note that an object must at most have the attribute of HoldRest.
See DefineObjectType.
\item {\tt MakeSeparable} (in ``System.m'') \newline
MakeSeparable[ operator[parameters][f] ] will assume that the
operator is separable in the parameters and decompose the operation
into a series of nested one-dimensional operators on f.
For parameters that are matrices, only their diagonal elements
will be extracted.
See SEPARABLE.
\item {\tt MakeSignal} (in ``Signal.m'') \newline
MakeSignal[] returns a signal object with one slot for system use.
MakeSignal[var] returns a signal object with slot
IndependentVariable set to var and with one slot defined for
system use.
MakeSignal[signal, n, property1, value, property2, value, ...]
can be used to define a signal as a function of n (the properties
are optional).
If the signal is multidimensional, n will be a list of variables
(one for each dimension, like \{n1, n2, n3\} in the three-dimensional
case).
Possible signals include Impulse[n], Step[n], FIR[n, \{h0, h1, ...\}],
and IIR[n, \{a0, a1, ...\}]. See MyMakeSignal.
\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 MemoryCosts} (in ``CostFunctions.m'') \newline
MemoryCosts[ oper[p1, p2, ..., pN][sig1, sig2, ..., sigN ] ]
returns the number of memory elements needed to implement the
operator oper (having parameters p1, p2, ..., pN) in terms
of the sampling rate of the input signals sig1, sig2, ..., sigN.
\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 MoveOperatorsToFront} (in ``System.m'') \newline
MoveOperatorsToFront[head operator, signals, signals to move,
operator to move] will move all operator to move operators
contained in signals to move to the front of the expression formed
by the head operator operating on signals.
For example, MoveOperatorsToFront[ Convolve[n],
\{ x[n], Shift[2,n][y[n]] \}, \{ Shift[2,n][y[n]] \}, Shift ]
yields Shift[2,n] [ Convolve[n] [ x[n], y[n] ] ].
This is a valid rewriting of the original expression.
In this case, Convolve[n] [x[n], Shift[2,n][y[n]]].
This object is used in the system rewrite rules to rewrite
properly an operator operating on more than one signal.
\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 MultiDLookup} (in ``TransSupport.m'') \newline
MultiDLookup[options, timevars, transformvars] expands any
multidimensional transform pairs into a set of one-dimensional
transform pairs.
\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 MultiplicationCosts} (in ``CostFunctions.m'') \newline
MultiplicationCosts[ oper[p1, p2, ..., pN][sig1, sig2, ..., sigN ] ]
returns the number of multiplications needed to implement the
operator oper (having parameters p1, p2, ..., pN) in terms
of the sampling rate of the input signals sig1, sig2, ..., sigN.
\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 uses GetRootList to find the roots and then calls Apart.
MyApart[rational polynomial, x, filter] specifies a filter
for GetRootList: Identity for rational and N for approximate roots.
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 MyMakeSignal} (in ``Signal.m'') \newline
MyMakeSignal[signal, var] extends the possibilities of MakeSignal.
It allows the definition of standard signals as a function of var.
Signals defined this way include FIR[n, h0, h1, ...] and
IIR[n, a0, a1, ...].
\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 NextFun} (in ``Signal.m'') \newline
NextFun is a method for stream-based signals describing how to
compute the next value.
\item {\tt NormalizeSamplingMatrix} (in ``LatticeTheory.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 Nth} (in ``Lisp.m'') \newline
Nth[n, list] returns the nth element in the list
with n=0 indicating the first element.
\item {\tt NthCdr} (in ``Lisp.m'') \newline
NthCdr[n, list] returns the part of the list from the nth element
to the end of the list, with n=0 indicating the first element.
\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 OperatorToPtolemy} (in ``Ptolemy.m'') \newline
OperatorToPtolemy[op[parameters]] converts an operator to a
Ptolemy star.
\item {\tt OutOfDomainValue} (in ``Signal.m'') \newline
OutOfDomainValue[signal] is the value to return if the signal is
accessed outside of its region of support.
This value defaults to zero.
\item {\tt OutputPortName} (in ``Ptolemy.m'') \newline
OutputPortName[op] indicates the name of the signal output port
in Ptolemy for the operator op.
By default, the function returns output .
\item {\tt OverlappingRegions} (in ``Polygons.m'') \newline
OverlappingRegions[r] enumerates each pair of non-identical
regions in r and returns the union of all overlapping regions
as a list of polygons (an empty list means no overlap).
OverlappingRegions[region1, region2] returns a list of polygons
that represents the overlap between region1 and region2.
Multiple overlapping regions may be returned.
Remove redundant regions with the Union command.
\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 PartitionIntoSubsets} (in ``SupCode.m'') \newline
PartitionIntoSubsets[s, n] returns all of the ways set s can be
partitioned into n subsets as a tree.
\item {\tt PastValues} (in ``Signal.m'') \newline
PastValues is a slot that remembers previously computed signal values.
\item {\tt PatternQ} (in ``SupCode.m'') \newline
PatternQ[expr] returns True if the head of expr is Pattern.
\item {\tt PerOutputSamplingRate} (in ``CostFunctions.m'') \newline
PerOutputSamplingRate[inputrate, blocksize(s), numsamples, var(s)]
computes the sampling rate per output sample for block operations
given the input sampling rate (matrix) inputrate, the size of blocks
in each dimension blocksize(s), the total number of samples processed
numsamples, and the variable(s) var(s) on which the block operation
is performed.
\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 Piecewise} (in ``Convolution.m'') \newline
Piecewise is an option for the piecewise convolution routines.
See ConvolutionOutputForm for more information.
\item {\tt PiecewiseConvolution} (in ``Convolution.m'') \newline
PiecewiseConvolution[f, g, v] convolves the piecewise functions
f and g with respect to the variable v.
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 end point, right end point\}.
The F-interval notation represents a finite-extent function or
sequence when the end points 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 SetConvolutionDomain.
See also CTPiecewiseConvolution and DTPiecewiseConvolution.
\item {\tt PlotList} (in ``Convolution.m'') \newline
PiecewisePlot[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.
The old name for this function is PlotList.
\item {\tt PlusByConstant} (in ``Ptolemy.m'') \newline
PlusByConstant[a, const] indicates the sum of a and the
constant const.
\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 PointwiseSignal} (in ``Signal.m'') \newline
PointwiseSignal is a type of signal in which signal values are
computed point-by-point.
Such a signal does not depend on previous outputs or inputs.
\item {\tt PointwiseSignalQ} (in ``Signal.m'') \newline
PointwiseSignalQ[signal] returns True if the values of the
signal are computed point-by-point, and the value at each
point is independent of other values of the signal.
\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 if the Return option
is Roots or the pole-zero plot(s) if the Return option is Graphics.
\item {\tt PolygonArea} (in ``Polygons.m'') \newline
PolygonArea[ Polygon[ \{p0, p1, ...\} ] ] will compute the area
of the polygon with vertices p0, p1, ...
\item {\tt PolygonToTriangles} (in ``Polygons.m'') \newline
PolygonToTriangles[polygon] will slice the polygon into
triangles by connecting each vertex with the centroid.
\item {\tt PolyphaseDownsample} (in ``SigProc.m'') \newline
PolyphaseDownsample[m, h, n][x] is equivalent to downsampling
x by m (w/r to n) and then filtering (w/r to n) by a polyphase
form of the FIR filter h.
Hence, the filtering is carried out at the lower sampling rate.
\item {\tt PolyphaseResample} (in ``SigProc.m'') \newline
PolyphaseResample[l, h, m, n][x] represents an efficient polyphase
structure to perform sampling rate changes by a rational factor.
The structure is equivalent to first upsampling by l, then filtering
by the FIR filer h, and finally downsampling by m.
In the efficient structure, the filtering is carried out at the
lower sampling rate.
The resampling factors (matrices) l and m must be relatively prime.
\item {\tt PolyphaseUpsample} (in ``SigProc.m'') \newline
PolyphaseUpsample[l, h, n][x] is equivalent to filtering (w/r to n)
x by a polyphase form of the FIR filter h and then upsampling the
result by l (w/r to n).
Hence, the filtering is carried out at the lower sampling rate.
\item {\tt Pop} (in ``StackQueue.m'') \newline
Pop[stack] removes and returns the value at the top of the stack.
\item {\tt PostUpdateFunction} (in ``Signal.m'') \newline
PostUpdateFunction is a method which is applied to signal after
each computation of a new signal value.
\item {\tt PreUpdateFunction} (in ``Signal.m'') \newline
PreUpdateFunction is a method which is applied to signal before
each computation of a new signal value.
\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 PrintName} (in ``Signal.m'') \newline
PrintName[signal] is the name of the signal which is what is output
on the screen when the signal is to displayed.
\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 Ptolemy} (in ``Ptolemy.m'') \newline
Ptolemy is a block diagram simulation environment developed at
the Department of Electrical Engineering and Computer Science
at the University of California at Berkeley.
It features the ability to simulate algorithms that mix
synchronous data flow, dynamic data flow, and discrete event
methods of computation.
The environment can also generate C and assembly language programs.
See also PtolemyProgram and PtolemyForm.
\item {\tt PtolemyForm} (in ``Ptolemy.m'') \newline
PtolemyForm[expr] generates the Ptolemy code that is equivalent
to the signal processing expression expr.
It is called by PtolemyProgram to generate self-contained
Ptolemy simulations.
See also Ptolemy and PtolemyProgram.
\item {\tt PtolemyProgram} (in ``Ptolemy.m'') \newline
PtolemyProgram[expr, \{v1, v1min, v1max\}, \{v2, v2min, v2max\}, ...]
generates a complete Ptolemy program for simulation based
on the processing of in variables v1, v2, ... over the specified
range of values.
The following options are supported:
Dialogue (see Dialogue), Prolog (see \$PtolemyProlog), and
Plot (True or Automatic will plot the result of the algorithm expr).
For example, the user can add aa -$>$ 2 to specify that the constant
aa in expr be assigned the value 2 in the generated Ptolemy code.
See also Ptolemy and PtolemyForm.
\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 Push} (in ``StackQueue.m'') \newline
Push[stack, element] adds the element to the top of the stack.
\item {\tt QueryTheUser} (in ``SupCode.m'') \newline
QueryTheUser[ expression, head, function ] asks the user to provide
a value for the function applied to expression (where the head of the
expression is head).
The information will be entered permanently in the Mathematica
environment because the following piece of code will be generated:
head/: function[ expression ] := value.
\item {\tt Queue} (in ``StackQueue.m'') \newline
Object head for a queue structure.
\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[e1, e2, ...] returns the greatest common divisor of the
numerators of elements ei divided by the greatest common divisor of
the denominators of elements ei.
Every element must be a polynomial or a number.
Each real-valued and complex-valued element is rationalized
before GCD's are computed.
\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 ``Lisp.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 ReadOnlyList} (in ``Slot.m'') \newline
ReadOnlyList is the slot which keeps track of the slots/methods
which can not be altered.
\item {\tt ReadOnlySlotQ} (in ``Slot.m'') \newline
ReadOnlySlotQ[object, slot or method] returns True if the
slot or method can not be altered in the object.
\item {\tt ReadSlot} (in ``Slot.m'') \newline
ReadSlot[object, slot] returns the contents of the slot slot
in object.
Note that object is an unevaluated symbol.
\item {\tt ReadTextFile} (in ``SupCode.m'') \newline
ReadTextFile[ filename ] reads a string that is the
entire text file.
To write it out in the same form in which it was read, use
OutputForm[ ReadTextFile[ filename ] ] $>$$>$ filename.copy .
\item {\tt RealOrComplex} (in ``Signal.m'') \newline
RealOrComplex[signal] returns True if the signal's output values
are real-valued or complex-valued.
\item {\tt RealQ} (in ``Lisp.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 RearrangePolygon} (in ``Polygons.m'') \newline
RearrangePolygon[ polygon ] rearranges the listing of vertices
in order to place the vertex that has the smallest x-coordinate
among those that have the smallest y-coordinates as the first vertex.
\item {\tt RegUnimodularResMatrixQ} (in ``LatticeTheory.m'') \newline
RegUnimodularResMatrixQ[mat] gives True if mat is a resampling
matrix with a determinant of +1 or -1, and gives False otherwise.
See also ResamplingMatrix.
\item {\tt RelativelyPrime} (in ``LatticeTheory.m'') \newline
RelativelyPrime[a, b] returns True if a and b are relatively prime,
and gives False otherwise.
The data types of a and b must be the same.
Possible data types are integers, polynomials, and
square integer matrices (a.k.a. resampling matrices).
For non-diagonal resampling matrices, a third argument of
Right or Left is necessary to direct the matrix factorization
to occur on the right (using GCLD) or left (using GCRD).
See also GCD, PolynomialGCD, and ResamplingMatrix.
\item {\tt RemoveOptions} (in ``SupCode.m'') \newline
RemoveOptions[optionlist, options] removes the options
from optionlist.
\item {\tt ReorderResampling} (in ``LatticeTheory.m'') \newline
ReorderResampling[resmat, vars, allvars] rewrites
the resampling matrix resmat and the variables vars associated
with it so that the resampling is carried out by the order
of variables specified by allvars.
Therefore, vars must be a subset of allvars.
\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 ``LatticeTheory.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 ``LatticeTheory.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 RewriteSummations} (in ``SigProc.m'') \newline
RewriteSummations[f, t, tlower, tupper] rewrites Summation
and Periodic operators that appear in f so that the domain
of the new expression includes t in [tlower, tupper].
It relies on the Extent1D function to compute the domain
of the arguments to the Periodic and Summation operators.
\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 at increments of step.
In order to connect the points, the function f(z) will be factored
symbolically with respect to z.
All closed-form factors of reasonable size will be graphed as
parametric plots.
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 RotateAxes} (in ``SigProc.m'') \newline
RotateAxes[a, \{x,y\}][f] represents the rotation of the
multi-dimensional function f in the (x,y) plane about the
origin by a radians.
Applying the object TheFunction to the RotateAxes operator will
generate a mathematical expression for the rotated function.
\item {\tt RowHermiteForm} (in ``LatticeTheory.m'') \newline
RowHermiteForm[F] returns \{X, H\} where X is the n x n regular
unimodular matrix that puts the m x n integer matrix F into
lower triangular (row Hermite) form H (which is m x n).
That is, F . X = H.
\item {\tt Rplus} (in ``ROC.m'') \newline
Rplus[ $<$r-plus$>$ ] is the head for the R+ value in a transform.
\item {\tt RuleAppliesQ} (in ``SupCode.m'') \newline
RuleAppliesQ[expr, rule] returns True if rule applies to expr.
RuleAppliesQ[head[expr1, expr2, ..., exprn], rule, head] returns
True if the rule applies to each expression expr1, expr2, ...,
exprn.
\item {\tt SEPARABLE} (in ``System.m'') \newline
SEPARABLE[system] is a system property.
It identifies the components of multidimensional systems that can
decomposed into cascades of one-dimensional operations.
SEPARABLE[system] returns True if the operator system is separable
in all variables, False is separable in no two variables, or
a list of variables in which it is separable.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt SHIFTINVARIANT} (in ``System.m'') \newline
SHIFTINVARIANT is a system property.
It means that a shift in the input causes the same shift
in the output.
It also serves as a function.
SHIFTINVARIANT[system] returns True if the
operator system is shift-invariant.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt SPHeuristicRewrite} (in ``Heuristics.m'') \newline
SPHeuristicRewrite[expr, rules] tries to rewrite expressions
on the same level of expr together using the list of rules.
\item {\tt SPIntegrationRules} (in ``SigProc.m'') \newline
SPIntegrationRules is a collection of integral rules that augment
the abilities of Mathematica's Integrate command.
\item {\tt SPLessGreaterRules} (in ``SupCode.m'') \newline
SPLessGreaterRules are a collection of rules for rewriting
expressions involving inequalities.
They are not included in the SPSimplificationRules.
\item {\tt SPRecursiveRewrite} (in ``Heuristics.m'') \newline
SPRecursiveRewrite[expr, rules] only returns a fully rewritten
version of the signal processing expression expr.
The Rewrite knowledge base is let loose on the expression expr
without any guidance, but an upper limit on the number of iterations
can be set through the MaxIterations option.
The user can see the intermediate expressions by setting the
Dialogue option to True or All.
\item {\tt SPSimplificationRules} (in ``SupCode.m'') \newline
SPSimplificationRules are a collection of simplification rules
that are not carried out by Simplify.
These rules require too much overhead to encode them directly
into Mathematica.
See also SPSimplify.
\item {\tt SPSimplify} (in ``SigProc.m'') \newline
SPSimplify[e] will simplify expression e according to Mathematica's
simplification rules and the rules in SPSimplificationRules.
At each iteration, Simplify is called and SPSimplificationRules
is applied to the result.
Unlike Simplify, SPSimplify supports a Dialogue option.
You can specify which symbols to treat as real variables by using
the Variables option.
\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 SPproperties} (in ``System.m'') \newline
SPproperties contains a list of currently recognized
system properties like LINEAR.
\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 SPsystems} (in ``System.m'') \newline
SPsystems is a list of all recognized systems.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
New ones can be defined by using DefineSystem.
\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 SamplingRate} (in ``CostFunctions.m'') \newline
SamplingRate[expr, var] returns the sampling rate (matrix) of the
expression expr with respect to the discrete variable (variables)
var.
SamplingRate assumes that the input signals for multi-input
operators have been sampled at the same rate.
\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.
The powers of z that are functions of z are not considered.
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 ``Lisp.m'') \newline
Second[list] returns the second element of list.
\item {\tt Self} (in ``Signal.m'') \newline
Self is a pre-defined slot that is bound to the entire object
of which it is a member.
It can be used as a variable in methods and slots.
\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\}] becomes
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\}] returns
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.
It resets the global variable \$ConvolutionDomain.
It returns domain on success, and Null on error.
\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 SetExclusiveOr} (in ``Lisp.m'') \newline
SetExclusiveOr[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 Signal} (in ``Signal.m'') \newline
A signal is an object with head Signal.
From the work of Cory Myers, possible slots include:
Bandwidth, CenterOfSymmetry, End, EndBandwidth, Period, Start,
StartBandwidth, Support, and Symmetry.
Possible additional slots are:
CurrentValue, DataType, Dimensions, FrequencyVariables,
Implementation, Length, OutOfDomainValue, TheFunction,
TimeVariables, ZTransData, ZVariables, CurrentIndex,
NextFun, PreUpdateFunction, and PostUpdateFunction.
Multidimensional signals are supported. See MakeSignal.
\item {\tt SignalCleanup} (in ``SigProc.m'') \newline
SignalCleanup[ expr, t, nstart, nend ] converts the signal
expression expr in variables t into a normal Mathematica expression
that can be plotted over the interval [nstart, nend].
It returns a list of two expressions: the first consists of the
Delta functions extracted from expr, and the second is the rest
of the expression.
\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 SignalQ} (in ``Signal.m'') \newline
SignalQ[x] returns True if the head of x is Signal.
\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 SmithChart} (in ``SmithChart.m'') \newline
SmithChart displays a Smith Chart by issuing the command
Show[SmithChartGraphics, DisplayFunction:$>$\$DisplayFunction].
Function written by William Anklam.
\item {\tt SmithChartGraphics} (in ``SmithChart.m'') \newline
SmithChartGraphics returns the -Graphics- primitives required to
plot a Smith Chart.
SmithChartGraphics is meant to be used within the Show[] command
function so that the Smith Chart can be displayed along with data.
Function written by William Anklam.
\item {\tt SmithChartPlot} (in ``SmithChart.m'') \newline
SmithChartPlot[y, \{f, fmin, fmax\}] plots the impedance function y
on a Smith chart.
Function written by William Anklam.
\item {\tt SmithEqualizedForm} (in ``LatticeTheory.m'') \newline
SmithEqualizedForm[A] returns a list of three matrices U, D, and V.
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 integer matrix such that $|$det(D)$|$ = $|$det(A)$|$.
The elements of D will be approximately equal to one another.
With one argument, this routine will return a U matrix whose columns
are approximately orthogonal to one another (by calling SmithLLLForm
to perform the initial Smith form decomposition).
SmithEqualizedForm[A, \{U, D, V\}] equalizes the diagonal elements
of the diagonal matrix D.
\item {\tt SmithFormMinimizeU} (in ``LatticeTheory.m'') \newline
SmithFormMinimizeU[U, D, V] will make the regular unimodular U
matrix as close to an identity matrix as possible.
SmithFormMinimizeU[U, D, V, k, l] will make the kth and
lth columns of the regular unimodular matrix U as close to the kth
and lth columns of an identity matrix.
In both cases, the minimization occurs in a least-squares sense
without altering the diagonal matrix D.
This routine supports a Dialogue option.
This routine directly computes and then returns the new \{U, D, V\}.
\item {\tt SmithFormMinimizeV} (in ``LatticeTheory.m'') \newline
SmithFormMinimizeV[U, D, V] will make the regular unimodular V
matrix as close to an identity matrix as possible.
SmithFormMinimizeU[U, D, V, k, l] will make the kth and
lth columns of the regular unimodular matrix V as close to the kth
and lth rows of an identity matrix.
In both cases, the minimization occurs in a least-squares sense
without altering the diagonal matrix D.
This routine supports a Dialogue option.
This routine directly computes and then returns the new \{U, D, V\}.
\item {\tt SmithFormPivot} (in ``LatticeTheory.m'') \newline
SmithFormPivot[U, D, V, k, l, f] pivots a factor f from the lth
diagonal element of D to the kth diagonal element of D.
The function returns a list of the new U, D, and V.
The pivot can only take place if f is a factor of the lth element
of D and if f is relatively prime to Dkk Dll' / gcd(Dkk, Dll')\verb:^:2
where Dkk is the kth diagonal element of D and Dll' is the lth
diagonal element of D divided by f.
An optional seventh argument specifies the minimization in a
Frobenius norm sense--- Left for U, Right for V, and None for none.
The default is None.
\item {\tt SmithFormSameU} (in ``LatticeTheory.m'') \newline
SmithFormSameU[smithfun, s1, s2] 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, d1, v1\}, \{u2, d2, v2\}\},
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 ``LatticeTheory.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, d1, v1\}, \{u2, d2, v2\}\},
where cond is True of False depending on whether or not matrices
m1 and m2 can be decomposed using the same V.
\item {\tt SmithLLLForm} (in ``LatticeTheory.m'') \newline
SmithLLLForm[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 determinants of +1 or -1 and D is a diagonal matrix
of integer components such that $|$det(D)$|$ = $|$det(A)$|$.
SmithLLLForm[A, smithfun] uses smithfun (which is the name of a
routine) instead of the default routine SmithOrderedForm.
The algorithm uses Mathematica's LatticeReduce command which is
the Lenstra-Lenstra-Lovasz (LLL) lattice reduction algorithm.
The Min option tells SmithLLLForm to return either a U or a V with
minimum Frobenius norm: Left means U (default) and Right means V.
SmithLLLForm supports the same options as does SmithOrderedForm.
\item {\tt SmithMcMillanForm} (in ``LatticeTheory.m'') \newline
SmithMcMillanForm[ratmat] factors the rational matrix ratmat
into the product of U D V, where U and V are integer matrices
having a determinant of +1 or -1 and D is a diagonal matrix
having rational integers along the diagonal.
The routine factors out the LCM of the denominators of ratmat
decomposes the resulting integer matrix into Smith form, and
multiplies the diagonal matrix by the rational factor.
SmithMcMillanForm[smithfun, ratmat] will determine the
Smith-McMillan form from the Smith form returned by smithfun.
\item {\tt SmithNormalForm} (in ``LatticeTheory.m'') \newline
SmithNormalForm[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 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.
SmithNormalForm supports a Dialogue option.
If Dialogue is True or All, SmithNormalForm will show immediate steps.
See also SmithOrderedForm and SmithReducedForm.
\item {\tt SmithOrderedForm} (in ``LatticeTheory.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 or -1 and D is a diagonal matrix
of integer components such that $|$det(D)$|$ = $|$det(A)$|$.
The components along the diagonal of D are positive and sorted.
The starting point is the result of the SmithNormalForm routine.
SmithOrderedForm[A, \{U, D, V\}] adjusts D as described
previously and then returns the new \{U, D, V\}.
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 ``LatticeTheory.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)$|$.
The diagonal elements are sorted down the diagonal and each one
is a factor of the next one.
Note that the starting point for this algorithm is the
SmithOrderedForm routine.
SmithReducedForm[A, \{U, D, V\}] adjust D as described previously
and returns the new \{U, D, V\}.
SmithReducedForm supports a Dialogue option.
If True or All, SmithNormalForm will show immediate steps.
See also SmithNormalForm and SmithOrderedForm.
\item {\tt Some} (in ``Lisp.m'') \newline
Some[query, expr] returns True if at least one element of expr
satisfies the test query.
Some[query, expr, levelspec] returns True if every part of the
expression expr satisfies the test query.
\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 slot in the DFTData data structure which indicates
when starting point of the DFT sequence.
\item {\tt StartBandwith} (in ``Signal.m'') \newline
StartBandwith[signal] returns the starting location of the bandwidth
of the signal.
For signals that are not bandlimited,
this method will return -Infinity which is the default value.
\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 StreamSignal} (in ``Signal.m'') \newline
StreamSignal is a type of signal that computes its outputs one
after another usually without reference to past values.
\item {\tt StreamSignalQ} (in ``Signal.m'') \newline
StreamSignalQ[signal] returns True if the values of signal are
computed one at a time in some order.
The value at each point can be dependent on previously-computed
values, state information, etc.
Signals generated by finite state machines are stream signals.
\item {\tt StripPackage} (in ``SupCode.m'') \newline
StripPackage[symbol] returns the symbol (as a string) after its
context has been removed.
To remove the package definition from every symbol in expression,
use MapAll[StripPackage, expression].
\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 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 ``Lisp.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 SymmetricPulseConvolutions} (in ``Convolution.m'') \newline
SymmetricPulseConvolutions[c, a, t, n] convolves a symmetric pulse
with itself n - 1 times.
The symmetric pulse has amplitude c and is defined for the
continuous real variable t over the interval [-a, a].
The function returns a formula.
Therefore, SymmetricPulseConvolutions[c, a, t, 1] simply returns
the symmetric pulse formula c CPulse[2 a, t + a].
\item {\tt SystemProperties} (in ``System.m'') \newline
SystemProperties[system] will show the properties attached to
of an operator or list of operators.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
See also DefineSystem and SystemQ.
\item {\tt SystemQ} (in ``System.m'') \newline
SystemQ[system] will give True if system is in the SPsystems list,
and False otherwise.
Note that a system is a (parameterized) operator to which
DefineSystem has attached properties.
For example, by default, Shift[L, n] has been installed as a system,
but Shift without the parameters has not.
\item {\tt SystemRewriteRules} (in ``RewriteRules.m'') \newline
SystemRewriteRules contains a list of over 50 rewrite rules for
operators (systems) .
This rule is composed of three other rule bases:
(1) rules based on operator properties,
(2) rules for single rate digital signal processing, and
(3) rules for multirate digital signal processing.
The rules in (1) are patterned after those found in Myers' Signal
Processing Language and Interactive Computing Environment (SPLICE)
and Covell's Algorithm Design Environment (ADE).
\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 ``Lisp.m'') \newline
Third[list] returns the third element of list.
\item {\tt TimesByConstant} (in ``Ptolemy.m'') \newline
TimesByConstant[a, const] indicates the product of a and the
constant const.
\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 TopElement} (in ``StackQueue.m'') \newline
TopElement[packet] returns the first element in the data packet.
This is the top of the stack if packet is a stack.
This is the next in the queue if packet is a queue.
The packet remains unaltered.
\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 TransformDialogue} (in ``TransSupport.m'') \newline
TransformDialogue[ strategy, options, arg1, arg2, ... ] is the
routine that displays textual dialogue about the strategy being used
by a particular transform.
\item {\tt TransformFixUp} (in ``TransSupport.m'') \newline
TransformFixUp[time var, transform var, options,
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] \} ].
To specify a region of convergence, use
TransformLookup -$>$ \{ x[n] :$>$ \{ X[z], rm, rp \} \}.
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] \} ].
A region of convergence can be specified for each dimension.
For the z- and Laplace transform rule bases, one can also specify
a region of convergence associated with the transform pairs.
\item {\tt TriangleModWithSquare} (in ``Polygons.m'') \newline
TriangleModWithSquare[ Polygon[\{v1, v2, v3\}], \{ll, ur\} ] will
compute the triangle with vertices v1, v2, and v3 modulo the square
with lower-left corner coordinates ll and upper-right corner
coordinates ur.
\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 sequence (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 which can be
a negative or positive number.
If this routine returns 1 or -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 UpsampledSystem} (in ``LatticeTheory.m'') \newline
UpsampledSystem[expr, vars] returns a resampling matrix and
a set of linearly coupled variables taken from the master list vars.
For example, UpsampledSystem[Cos[w1 + w2] Sin[w1 - w2], \{w1, w2\} ]
will return \{ \{\{1,1\},\{1,-1\}\}, \{w1,w2\} \}.
In this case, the dot product of the resampling matrix and the
variable list give \{w1 + w2, w1 - w2\}.
A third optional argument would be a function to extract coefficients
that takes an expression, a list of variables, and a value to return
on failure.
\item {\tt ValidDecimatorBaseband} (in ``Decimation.m'') \newline
ValidDecimatorBaseband[ Polygon[pointlist] ] determines whether or
not the baseband represented by the polygon is a valid passband
for a integer decimator structure.
The routine returns \{ valid, passband, matrix \} where valid
is True or False, passband is the baseband whose centroid has been
shifted to the origin, and matrix is the downsampling matrix
of the decimator.
\item {\tt ValidIntervalQ} (in ``Convolution.m'') \newline
ValidIntervalQ[i] returns True if i is a valid F-interval, and
gives False otherwise.
An F-interval is an interval of the form \{f, leftendp, rightendp\}
where f is a function and leftendp $<$ rightendp unless f is an
impulse function in which case leftendp must equal rightendp.
In a valid F-interval, leftendp and rightendp must be numbers.
See also IntervalQ.
\item {\tt ValidOperatorQ} (in ``System.m'') \newline
ValidOperatorQ[system, signal1, signal2, ...] will return True
if every signal can be processed by the system.
For example, False would be returned if system was only a
discrete system and signal1 was a continuous signal.
\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 VectorConvolution} (in ``Convolution.m'') \newline
VectorConvolution[vector1, vector2] convolves two vectors that
represent samples of function.
\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 WriteSlot} (in ``Slot.m'') \newline
WriteSlot[object, slot, value] attempts to write over the slot
slot in object.
If the slot slot is read-only, then object is returned unaltered.
If the slot is not write protected, then the slot slot in object
is overwritten with value.
Note that object is an unevaluated symbol and that a slot value
cannot be a collection of values like (1, 2, 3).
\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.
\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 ZPolynomial} (in ``SupCode.m'') \newline
ZPolynomial[m, n] is an mth order polynomial in the discrete
variable n defined by the product of (-n - k) for k = 0 ... m-1.
The z-transform of the product of this polynomial and some function
f[n] gives z\verb:^:m times the mth derivative of F(z).
\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$>$.
The routine returns 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.
The forward transform of large expressions will be found much faster
if automatic simplification is disabled by using Simplify -$>$ False.
\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
\end{enumerate}
\end{document}