(*^

::[paletteColors = 128; 
	fontset = title, "Times", 24, L2, center, bold, nohscroll;
	fontset = subtitle, "Times", 18, L2, center, bold, nohscroll;
	fontset = subsubtitle, "Times", 14, L2, center, bold, nohscroll;
	fontset = section, "Times", 18, L2, bold, nohscroll, grayBox;
	fontset = subsection, "Times", 14, L2, bold, nohscroll, blackBox;
	fontset = subsubsection, "Times", 12, L2, bold, nohscroll, whiteBox;
	fontset = text, "Times", 14, L2, nohscroll;
	fontset = smalltext, "Times", 12, L2, nohscroll;
	fontset = input, "Courier", 14, L2, bold, nowordwrap;
	fontset = output, "Courier", 14, L2, nowordwrap;
	fontset = message, "Courier", 14, L2, R21845, G21845, B21845, nowordwrap;
	fontset = print, "Courier", 14, L2, nowordwrap;
	fontset = info, "Courier", 14, L2, nowordwrap;
	fontset = postscript, "Courier", 14, L2, nowordwrap;
	fontset = name, "Times", 12, L2, italic, R21845, G21845, B21845, nowordwrap, nohscroll;
	fontset = header, "Times", 12, L2;
	fontset = footer, "Times", 12, L2, center;
	fontset = help, "Times", 16, L2, nohscroll;
	fontset = clipboard, "New York", 14, L2;
	fontset = completions, "Courier", 18, L2, nowordwrap;
	fontset = network, "Courier", 12, L2, nowordwrap;
	fontset = graphlabel, "Courier", 14, L2, nowordwrap;
	fontset = special1, "Times", 24, L2, center, italic, nowordwrap;
	fontset = special2, "Times", 20, L2, center, italic, nowordwrap;
	fontset = special3, "Times", 16, L2, italic, nowordwrap;
	fontset = special4, "New York", 16, L2, nowordwrap;
	fontset = special5, "New York", 20, L2, nowordwrap;]
:[font = title; inactive; ]

Summary of Signal Processing Objects
:[font = subtitle; inactive; ]

by

Brian Evans and James McClellan
:[font = subsubtitle; inactive; ]

Digital Signal Processing Laboratory
School of Electrical Engineering
Georgia Institute of Technology
Atlanta, GA  30332-0250

EMAIL:  evans@eedsp.gatech.edu
:[font = text; inactive; ]

		These are the objects introduced by the signal processing packages.  The abilities of the signal processing packages are demonstrated by seven notebooks (LaPlaceTest, zTransform, PiecewiseConvolution, AnalogFilters, etc.) and summarized in
:[font = help; inactive; ]
1.  B. L. Evans, J. H. McClellan, and W. B. McClure.  "Symbolic Transforms with Applications to Signal Processing".  The Mathematica Journal.  vol.1, issue #2.  Fall, 1990.  pp. 70-80.
:[font = help; inactive; ]
2.  B. L. Evans, J. H. McClellan, and K. A. West. "Mathematica as an Educational Tool for Signal Processing".  Proceedings of the IEEE Southeastcon '91.  April, 1991.  pp. 1162-1166.
:[font = help; inactive; ]
3.  B. L. Evans and J. H. McClellan. "Symbolic Analysis of Signals and Systems".  ch. 3. of Symbolic and Knowledge-Based Signal Processing  (eds. A. Oppenheim and H. Nawab).  Prentice-Hall:  Englewood Cliffs, NJ.  1992.
:[font = text; inactive; ]
The second reference also exists as the EducationalTool notebook.  The LaTeX file ``usersguide.tex'' covers the same material as does [1] and [2].
:[font = text; inactive; ]
		Version 2.4 of the signal processing packages is the first version to work simultaneously under versions 1.2 and 2.0 of Mathematica.  The new abilities of the signal processing packages are summarized in the SignalProcessingExamples notebook.
:[font = subsection; inactive; ]
$ConvolutionDomain
:[font = text; inactive; ]
$ConvolutionDomain is the default domain for all of the convolution  routines in the signal processing packages.  Use SetConvolutionDomain to reset its value. 
:[font = subsection; inactive; ]
ASPAnalyze
:[font = text; inactive; ]
ASPAnalyze[f, t] and ASPAnalyze[f, t, start, end]  will plot f(t) as a one-dimensional, continuous-time function  (real part shown as solid lines, imaginary part as dashed lines).  It will also print the strip of convergence, indicate stability  criteria, display the pole-zero diagram, and plot the magnitude  and phase responses.  For the two-dimensional version, t is a  list of two variables (like  {t1, t2 }) and start/end are optional  two-element lists specifying the range of the time-domain plot.  All non-variable symbols will be assigned a value of 1 when the  analyzer needs to generate a plot (override this by using options  like a - >  2). 
:[font = subsection; inactive; ]
AddChildToTree
:[font = text; inactive; ]
AddChildToTree[tree, parent, newchild] adds newchild under  every parent in tree. 
:[font = subsection; inactive; ]
AddDataType
:[font = text; inactive; ]
AddDataType[data type], AddDataType[data type, parent data type],  and AddDataType[data type, parent data type, Fourier data type]  will update the tree data type structure to include the  new data type and its corresponding Fourier domain  data type (which defaults to Complex).  If data type is a symbol, a predicate will be created by  appending a Q to the data type.  For example, positive integers are a subset of integers.  To add this data type, use  AddDataType[PositiveInteger, Integer, Complex].  This will also defined a new query function called IsPositiveIntegerQ. 
:[font = subsection; inactive; ]
AddT
:[font = text; inactive; ]
AddT[transq, t1, t2] adds the two transforms t1 and t2 together  and determines the new region of convergence.  The new  transform is returned as a list.  AddT[transq, t1, t2, lowerlimit]  uses lowerlimit as the lower limit on the region of convergence  values when combining ROC's (default is 0). 
:[font = subsection; inactive; ]
Aliasby
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
AllDataTypes
:[font = text; inactive; ]
AllDataTypes is the universal set of all data types.  Symbols cannot be associated with this data type. 
:[font = subsection; inactive; ]
AllSubsets
:[font = text; inactive; ]
AllSubsets[set] returns a list of all subsets of set.  AllSubsets[set, function] applies function to every subsetwith more than one element.  For example, AllSubsets[  {v1,v2,v3 }, Plus ] returns   {v1, v2, v3, v1 + v2, v1 + v2, v1 + v3, v1 + v2 + v3 }.  Note that the subset does not contain the null set. 
:[font = subsection; inactive; ]
Analog
:[font = text; inactive; ]
Analog is continuous-time signal processing. 
:[font = subsection; inactive; ]
AnalogFilter
:[font = text; inactive; ]
AnalogFilter[class, time-variable, order, epsilon, A,  transition-ratio, cutoff-frequency] will return an object with  head CIIR that represents a one-dimensional lowpass analog filter.  Here, class is one of Bessel, Butterworth, ChebyshevI, ChebyshevII,  Elliptic.  The last four arguments are filter parameters.  The value of the cutoff-frequency defaults to 1.  See also FilterParameters and FilterOrder. 
:[font = subsection; inactive; ]
Area
:[font = text; inactive; ]
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  }. 
:[font = subsection; inactive; ]
Arrow2D
:[font = text; inactive; ]
Arrow2D[tail, plotwidth, plotheight] returns a graphics object  which has the shape of an arrow. 
:[font = subsection; inactive; ]
AssociateDataType
:[font = text; inactive; ]
AssociateDataType[symbol, datatype] will indicate to all Signal  Processing Packages that the symbol is of type datatype.  This in no way restricts assignments to that symbol.  For example, AssociateDataType[n, Integer] means that  IsIntegerQ[n] will always be True, as well as  IsRationalQ[n], IsRealQ[n], and IsComplexQ[n].  Also see DefConstant and UnAssociateDataType. 
:[font = subsection; inactive; ]
AssociateItem
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
AutoCorrelation
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Bandpass
:[font = text; inactive; ]
Bandpass describes a filter that passes a band of frequencies  and rejects all others. 
:[font = subsection; inactive; ]
Bandstop
:[font = text; inactive; ]
Bandstop describes a filter that rejects a band of frequencies  and passes all others. 
:[font = subsection; inactive; ]
Bessel
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
BesselPolynomial
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
BezoutNumbers
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
BilinearTransformation
:[font = text; inactive; ]
BilinearTransformation[omega, w, k] assumes that two of three  arguments have value and will set the value of the unknown parameter.  It returns a list of the three arguments.  BilinearTransformation[omega, w, k, h, s, z, t] will transform  the analog transfer function h = f(s) into a digital transfer  function g(z).  Now, if h is instead a function of t and not of s,  then the Bilinear transformation will be applied to the Laplace  transform of h.  If h is an analog filter (see CIIR and CFIR),  then the result will be a digital filter (see IIR and FIR). 
:[font = subsection; inactive; ]
Butterworth
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
CConvolve
:[font = text; inactive; ]
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, ... 
:[font = subsection; inactive; ]
CFIR
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
CIIR
:[font = text; inactive; ]
CIIR[t,  {a0, a1, a2, ... }] represents the infinite impulse response  of an all-pole analog filter with gain 1, where a1, a2, ..., are the  feedback coefficients and a0 is the scaling factor of the output.  The Laplace transform of such an expression is  1 / ( a0 + a1 s + a2 s verb:^:2 + ... ).  By default, the input to the filter is a Dirac delta function.  An alternate input h can be specified by the code  CIIR[t,  {a0, a1, a2, ... }][h].  For the generalized N-dimensional IIR structure, the argument t  becomes a list of indices (like  {t1, t2 } for N=2) and the feedback  coefficients are specified by an N x N matrix.  Supports option Roots, which for 1-D filters is a list of poles. 
:[font = subsection; inactive; ]
CPulse
:[font = text; inactive; ]
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]]. 
:[font = subsection; inactive; ]
CStep
:[font = text; inactive; ]
CStep[t], a.k.a. Unit[-1][t], is the unit step function  which is 1 for t  >  0, 0 for t  <  0, and 1/2 at t = 0.  It is commonly used for continuous expressions t.  See also Step and Unit. 
:[font = subsection; inactive; ]
CTFTData
:[font = text; inactive; ]
CTFTData is the data-tag for the CTFT. 
:[font = subsection; inactive; ]
CTFTransform
:[font = text; inactive; ]
CTFTransform[f, t] or CTFTransform[f, t, w] computes the  continuous-time Fourier transform of f.  It has time argument(s) t  and frequency argument(s) w. 
:[font = subsection; inactive; ]
CTPiecewiseConvolution
:[font = text; inactive; ]
CTPiecewiseConvolution[f, g, t] carries out the one-dimensional,continuous-time piecewise convolution of f and g with respect to t.  See PiecewiseConvolution for valid representation of f and g.  Using F-interval notation  {function, left endpoint, right endpoint },  a Dirac delta is meant when function = Area[ < area > ]  (where  < area >  equals the area of under the impulse function) and  left endpoint = right endpoint (which is the location of the impulse). 
:[font = subsection; inactive; ]
ChebyshevI
:[font = text; inactive; ]
ChebyshevI is a type of infinite impulse response (IIR) filter  whose magnitude squared response is of the form  1/(1 + e verb:^:2 Tn(w/wc) verb:^:2) where e controls passband ripple,  w is the frequency variable, and wc is the cutoff frequency.  The term Tn(s) is the nth-order Chebyshev polynomial.  The magnitude response of the stopband monotonically decreases  with respect to frequency. 
:[font = subsection; inactive; ]
ChebyshevII
:[font = text; inactive; ]
ChebyshevII is a type of infinite impulse response (IIR) filter  whose magnitude squared response is of the form  1/(1 + e verb:^:2 Xn(w/wc) verb:^:2) where e controls stopband ripple,  w is the frequency variable, and wc is the cutoff frequency.  Here, Xn(w) = Tn(wr) / Tn(wr / w), where Tn(w) is the nth-order  Chebyshev polynomial.  The magnitude response of the passband  monotonically decreases with respect to frequency. 
:[font = subsection; inactive; ]
CirclePS
:[font = text; inactive; ]
CirclePS[r] and CirclePS[r, p] will return a graphics object,  a circle of radius r with plotstyle p.  In Mathematica 2.0, CirclePS makes use of the Circle primitive. 
:[font = subsection; inactive; ]
Combine
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
CombineDataType
:[font = text; inactive; ]
CombineDataType[ datatype1, datatype2, ...] resolves multiple  data types. 
:[font = subsection; inactive; ]
CommutableResamplingMatricesQ
:[font = text; inactive; ]
CommutableResamplingMatricesQ[downsamplingmat, upsamplingmat]  returns True if the two resampling operations are commutable. 
:[font = subsection; inactive; ]
ComplexAntiSymmetric
:[font = text; inactive; ]
ComplexAntiSymmetric is an abstract data type.  It indicates that the real and imaginary components of a  complex-valued sequence (or   function) are anti-symmetric.  See AssociateDataType. 
:[font = subsection; inactive; ]
ComplexQ
:[font = text; inactive; ]
ComplexQ[z] returns True if z is a complex number, False otherwise. 
:[font = subsection; inactive; ]
ComplexSymmetric
:[font = text; inactive; ]
ComplexSymmteric is an abstract data type.  It indicates that the real and imaginary components of a  complex-valued sequence (or function) are symmetric.  See AssociateDataType. 
:[font = subsection; inactive; ]
ComplexTo2DCoord
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ComplexTo2DCoordList
:[font = text; inactive; ]
ComplexTo2DCoordList[zlist] returns a list of coordinates  corresponding to the complex form of each element in the  zlist.  That is, zlist is mapped through ComplexTo2DCoord. 
:[font = subsection; inactive; ]
ConjT
:[font = text; inactive; ]
ConjT[transq, X(s), s] implements T { Conj {x(t) }  } -- >  X*(s*),  where X(s) is the transform of x(t). 
:[font = subsection; inactive; ]
ConstantQ
:[font = text; inactive; ]
ConstantQ[x] returns True if x is always constant.  If x is an atom, then x is constant it is a number or it x has  a Constant attribute.  If x is a function of the form f[arg1, arg2, ...], then x is  considered to be constant if arg1, arg2, ..., are constant. 
:[font = subsection; inactive; ]
ConstantTerm
:[font = text; inactive; ]
ConstantTerm[expr, x] returns the constant term of the  expression expr. 
:[font = subsection; inactive; ]
Continuous
:[font = text; inactive; ]
Continuous is a possible value for a signal's domain. 
:[font = subsection; inactive; ]
ConvertFromList
:[font = text; inactive; ]
ConvertFromList[l, t] converts a list of F-intervals in the form   {f, t1, t2 } to a signal processing expression.  The new expression will contain either Delta, CStep, and CPulse  functions (continuous-time) or Impulse, Step, and Pulse functions  (discrete-time) according to the value of the Domain option.  The default domain is the value of   ConvolutionDomain. 
:[font = subsection; inactive; ]
ConvertToList
:[font = text; inactive; ]
ConvertToList[e, t] converts the expression e to a  list of F-intervals in the form  {fun, left, right }.  The domain of the new expression is established according to the  value of the Domain option.  The default domain is the value of   ConvolutionDomain. 
:[font = subsection; inactive; ]
Convolve
:[font = text; inactive; ]
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, ... 
:[font = subsection; inactive; ]
ConvolveT
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
CorrelationSequence
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
DFT
:[font = text; inactive; ]
DFT[L, n, k] is the forward discrete Fourier transform operator.  Here, L is the DFT length(s), n is the time-domain variable(s), and  k is the frequency-domain variable(s).  Multidimensional DFT's are supported.  Applying TheFunction to the DFT operator will invoke  the DFT rule base (object DFTransform) if loaded. 
:[font = subsection; inactive; ]
DFTData
:[font = text; inactive; ]
Data-tag for the symbolic DFT. 
:[font = subsection; inactive; ]
DFTransform
:[font = text; inactive; ]
DFTransform[function, NumberOfPoints, TimeVariables,  FourierVariables, options] returns the DFT of function,  where function is a function of TimeVariables defined from  0 to NumberOfPoints - 1.  Note that only the first two arguments  are required and that DFTransform calls DTFTransform. 
:[font = subsection; inactive; ]
DSPAnalyze
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
DTFT
:[font = text; inactive; ]
DTFT[n, w] is the forward discrete-time Fourier transform operator.  Here, n is the time-domain variable(s), and w is the frequency-domain  variable(s).  Multidimensional DTFT's are supported.  Applying TheFunction to the DTFT operator will invoke the DTFT  rule base (object DTFTransform) if loaded. 
:[font = subsection; inactive; ]
DTFTData
:[font = text; inactive; ]
DTFTData is a data-tag. 
:[font = subsection; inactive; ]
DTFTransform
:[font = text; inactive; ]
DTFTransform[function, in variable(s), out variable(s), options]  returns the discrete-time Fourier transform of the input function.  Note that this transform may rely on the z-transform and the  substitution z = Exp[I w], which is not valid if the region of  convergence does not include the unit circle.  Also note that  only the first two arguments are required. 
:[font = subsection; inactive; ]
DTPiecewiseConvolution
:[font = text; inactive; ]
DTPiecewiseConvolution[f, g, n] carries out the one-dimensional,discrete-time piecewise convolution of f and g with respect to n.  See PiecewiseConvolution for the valid representations of f and g.  Using F-interval notation  {function, left endpoint, right endpoint },  an impulse (Kronecker delta) function is meant when function =  < value >   (where  < value >  equals the strength of the impulse function) and  left endpoint = right endpoint (which is the location of the impulse). 
:[font = subsection; inactive; ]
DataType
:[font = text; inactive; ]
DataType[expr1, expr2, ...] returns the data type which results  in the combination of data types in expr1, expr2, ....  To associate a data type with a new function aa, use  aa/: DataType[ aa[args ] ] := newdatatype.  Use AssociateDataType to associate data types with symbols.  Use AddDataType to add more data types to the data type rules base. 
:[font = subsection; inactive; ]
DataTypeQ
:[font = text; inactive; ]
DataTypeQ[datatype1, datatype2, ...] returns True if every  passed data type is valid and recognized by the DataType rules base.  Use AddDataType to add more data types to the rules base. 
:[font = subsection; inactive; ]
DataTypes
:[font = text; inactive; ]
DataTypes[] returns a listing of all recognized abstracted  data types.  DataTypes[datatype] returns a list of all symbols  associated with datatype.  DataTypes[datatype1, datatype2, ...] returns a sorted table of  symbols associated with the data types datatype1, datatype2, ....  All symbols having an associated data type can therefore be found  by the code fragment DataTypes[ DataTypes[] ]. 
:[font = subsection; inactive; ]
DefConstant
:[font = text; inactive; ]
DefConstant[symbol] simply sets the Constant attribute of symbol.  DefConstant[symbol, datatype] establishes the data type of the  symbol as datatype by calling AssociateDataType as well as  setting the symbol's Constant attribute. 
:[font = subsection; inactive; ]
DeleteFromTree
:[font = text; inactive; ]
DeleteFromTree[tree, node] deletes all nodes with info/name of node.  If the node is a parent, then the entire subtree is pruned. 
:[font = subsection; inactive; ]
Delta
:[font = text; inactive; ]
Delta[expr] is the Dirac delta function.  The area under this functions is 1 but it only has value  at the origin.  That is, Integrate[ Delta[t] g[t],  {t, t1, t2 } ] is g[0]  if t1  < = 0  < = t2, 0 otherwise.  It differs from the Kronecker delta function Impulse[t]. 
:[font = subsection; inactive; ]
DeltaPlot
:[font = text; inactive; ]
DeltaPlot is a object that can generate a plot of only Dirac delta  functions or a combination of Dirac delta functions and another plot.  In the first case, either four or six arguments are passed:  deltafuns, t, xmin, xmax, ymin, ymax. In the second case, either five or seven arguments are passed:  deltafuns, t, xmin, xmax, plot, ymin, ymax.  In both cases, ymin and ymax are the optional arguments.  DeltaPlot returns a list of plots suitable for sending to Show.  Note that 1-D Delta functions are plotted as arrows. 
:[font = subsection; inactive; ]
DerivativeT
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
DesignFilter
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Dialogue
:[font = text; inactive; ]
Dialogue is an option for all of the symbolic transforms, the  differential/difference equations solvers, and more.  Possible settings are False, True, or All, for no, partial, or  full justification.  In the case of symbolic transforms, a setting of True or All will  cause the rule base to describe strategies being applied to compute  the transform as well as the functions (if any) which it could not  transform.  If it set to All, then the rule base will also display each step  of the transform reasoning. 
:[font = subsection; inactive; ]
Difference
:[font = text; inactive; ]
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] ]. 
:[font = subsection; inactive; ]
Digital
:[font = text; inactive; ]
Digital is discrete-time signal processing. 
:[font = subsection; inactive; ]
Dirichlet
:[font = text; inactive; ]
Dirichlet[N, w] is the aliased sinc function.  which is defined as Sin[N w / 2] / ( N Sin [w / 2] ).  Aliases for Dirichlet are ASinc, AliasSinc, and AliasedSinc. 
:[font = subsection; inactive; ]
Discrete
:[font = text; inactive; ]
Discrete is a possible value for a signal's domain. 
:[font = subsection; inactive; ]
DiscreteGraphics
:[font = text; inactive; ]
DiscreteGraphics[ { {x1,y1 },  {x2,y2 }, ...  {xN,yN } }] will plot  the points as lines drawn from the x-axis to the y-value. 
:[font = subsection; inactive; ]
DistinctCosetVectors
:[font = text; inactive; ]
DistinctCosetVectors[resmat] returns a sorted list of all of the  distinct coset vectors associated with the resampling matrix resmat.  DistinctCosetVectors[resmat, U verb:^:-1, Lambda, V verb:^:-1] finds all of the  distinct coset vectors of resmat from its Smith Form  U Lambda V.  This is carried by finding the distinct coset vectors of the diagonal  matrix Lambda, mapping them by U verb:^:-1, and then taking each vector  modulo the resampling matrix resmat.  The returned coset vectors are not sorted.  
:[font = subsection; inactive; ]
Domain
:[font = text; inactive; ]
Domain is an option for many signal processing functions.  It is either Discrete or Continuous. 
:[font = subsection; inactive; ]
DomainScale
:[font = text; inactive; ]
DomainScale is an option for MagPhasePlot indicating the  scaling of the independent variable axis, Linear or Log,  for the magnitude plot. 
:[font = subsection; inactive; ]
Downsample
:[font = text; inactive; ]
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]. 
:[font = subsection; inactive; ]
DummyVariables
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Element
:[font = text; inactive; ]
Element[list, n] returns the nth element of list.  Also, Element[l1, l2, ..., n] returns ln. 
:[font = subsection; inactive; ]
Elliptic
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
EmptyQ
:[font = text; inactive; ]
EmptyQ[packet] returns True the packet of data is empty. 
:[font = subsection; inactive; ]
FIR
:[font = text; inactive; ]
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 asFIR[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. 
:[font = subsection; inactive; ]
FT
:[font = text; inactive; ]
FT[t, w] is the forward continuous Fourier transform operator.  Here, t is the time-domain variable(s) and w is the  frequency-domain variable(s).  Applying TheFunction to this operator will invoke the continuous-time  Fourier transform rule base (object CTFTransform) if loaded. 
:[font = subsection; inactive; ]
FTDataType
:[font = text; inactive; ]
FTDataType[datatype] returns the data type of datatype after  it has been sent through a Fourier transform. 
:[font = subsection; inactive; ]
FVariables
:[font = text; inactive; ]
FVariables is a data tag for the transform variables in a  Fourier transform. 
:[font = subsection; inactive; ]
FilterOrder
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
FilterParameters
:[font = text; inactive; ]
FilterParameters[delta1, delta2, epsilon, A, Eripple, ATT, nu]  fills in the values of the missing parameters.  It assumes that either the passband ripple (delta1) andthe stopband ripple (delta2) or epsilon (controls ripple) andA (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. 
:[font = subsection; inactive; ]
FilterTransform
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
FindRMinus
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
FindRPlus
:[font = text; inactive; ]
FindRPlus[rplus1, rplus2] and FindRPlus[rplus1, rplus2, lowerlimit]  returns the lesser of the two coordinates rminus1 and rminus2.  This function and FindRMinus[] are used to find the intersection of  two regions of convergence. 
:[font = subsection; inactive; ]
Finish
:[font = text; inactive; ]
Finish is a data-tag for the DFT. 
:[font = subsection; inactive; ]
FourierSimplify
:[font = text; inactive; ]
FourierSimplify[x] applies exponential to trigonometric rewrite  rules to expression x. 
:[font = subsection; inactive; ]
GenerateCode
:[font = text; inactive; ]
GenerateCode[object] converts object to a string (if necessary)  and then evaluates it (translates it to Mathematica code). 
:[font = subsection; inactive; ]
GeneratePattern
:[font = text; inactive; ]
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 ). 
:[font = subsection; inactive; ]
GenerateSymbol
:[font = text; inactive; ]
GenerateSymbol[namestring], GenerateSymbol[namestring, trailer],  and GenerateSymbol[namestring, trailer, header], generate a  symbol by concatenating header, namestring, and trailer. 
:[font = subsection; inactive; ]
GetAllExponents
:[font = text; inactive; ]
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 }. 
:[font = subsection; inactive; ]
GetAllFactors
:[font = text; inactive; ]
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 }. 
:[font = subsection; inactive; ]
GetDeltaFunctions
:[font = text; inactive; ]
GetDeltaFunctions[function, variable(s)] will extract  all delta functions from the argument function.  See also DeltaPlot. 
:[font = subsection; inactive; ]
GetOperatorVariables
:[font = text; inactive; ]
GetOperatorVariables[op] returns the variable(s) in the  parameterized operator op.  By default, GetOperatorVariables[ op[par1, par2, ...] ]  returns the first parameter, par1. 
:[font = subsection; inactive; ]
GetPosition
:[font = text; inactive; ]
GetPosition[list, element] returns the position which element  occurs in the list as an integer. 
:[font = subsection; inactive; ]
GetRMinus
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
GetRPlus
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
GetRoot
:[font = text; inactive; ]
GetRoot[rule] extracts the value from an expression like   {z - >  0. }, which is 0. in this case. 
:[font = subsection; inactive; ]
GetRootList
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
GetStateField
:[font = text; inactive; ]
GetStateField[state, field] returns the value of the slot  field n the list state. 
:[font = subsection; inactive; ]
GetValue
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
GetVariables
:[font = text; inactive; ]
GetVariables[expr] returns a list of all of the variables in  the expression expr.  See VariableQ for the definition of a variable. 
:[font = subsection; inactive; ]
HasAttributes
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Highpass
:[font = text; inactive; ]
Highpass describes a filter that passes all frequencies above  a cutoff frequency and rejects all others. 
:[font = subsection; inactive; ]
IIR
:[font = text; inactive; ]
IIR[n,  {a0, a1, a2, ... }] represents the infinite impulse response  of an all-pole filter with gain 1, where a1, a2, ..., are the  feedback coefficients and a0 is the scaling factor of the output.  In discrete time, the output of IIR is the solution to y[n]  in the difference equation  a0 y[n] + a1 y[n-1] + ... + aN y[n - N] =  impulse[n],  with y[n] = 0 for n  <  0.  By default, the input into the filter (a.k.a. the forcing function)  is an impulse.  An alternate input h can be specified by the code  IIR[n,  {a0, a1, a2, ... }][h].  For the generalized N-dimensional IIR structure, the argument n  becomes a list of indices (like  {n1, n2 } for N=2) and the feedback  coefficients are specified by an N x N matrix. 
:[font = subsection; inactive; ]
IIRFunction
:[font = text; inactive; ]
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 > . 
:[font = subsection; inactive; ]
Imaginary
:[font = text; inactive; ]
Imaginary is an abstract data type.  See AssociateDataType. 
:[font = subsection; inactive; ]
ImaginaryQ
:[font = text; inactive; ]
ImaginaryQ[z] returns True if z is a number whose real part is zero. 
:[font = subsection; inactive; ]
Impulse
:[font = text; inactive; ]
Impulse[n] is the unit Kronecker Delta function.  At n = 0, the function evaluates to 1.  Elsewhere, it evaluates to 0. 
:[font = subsection; inactive; ]
InRange
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
IncList
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
InfCheck
:[font = text; inactive; ]
InfCheck[expr] returns Infinity if expr is any Infinity form;  otherwise, expr is returned. 
:[font = subsection; inactive; ]
InfinityQ
:[font = text; inactive; ]
InfinityQ[a] will return True if a is Infinity, -Infinity,  ComplexInfinity, DirectedInfinity[], or DirectedInfinity[r]. 
:[font = subsection; inactive; ]
InformUserQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
InitTree
:[font = text; inactive; ]
InitTree[root] returns an empty tree with a root of root. 
:[font = subsection; inactive; ]
IntegerVectorQ
:[font = text; inactive; ]
IntegerVectorQ[arg] returns True if arg is a vector whoseelements are integers. 
:[font = subsection; inactive; ]
IntegrateT
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Interleave
:[font = text; inactive; ]
Interleave[n][x0, x1, ...] interleaves samples of signals  x0, x1, ..., which are functions of n.  This is only applicable to discrete signals. 
:[font = subsection; inactive; ]
IntersectsROC
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
IntervalQ
:[font = text; inactive; ]
IntervalQ[x] returns True if the argument x is an F-interval of  the form  {f, t1, t2 } where none of f, t1, or t2 are lists and  False otherwise. 
:[font = subsection; inactive; ]
IntervalsToFunction
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
InvCTFTransform
:[font = text; inactive; ]
InvCTFTransform[f, w, t] computes the inverse continuous time  Fourier transform of f with frequency arguments w and time  arguments t. 
:[font = subsection; inactive; ]
InvDFT
:[font = text; inactive; ]
InvDFT[L, k, n] is the inverse discrete Fourier transform operator.  Here, L is the DFT length(s), n is the time-domain variable(s), and  k is the frequency-domain variable(s).  Multidimensional inverse DFT's are supported.  Applying TheFunction to the InvDFT operator will invoke the  inverse DFT rule base (object InvDFTransform) if loaded. 
:[font = subsection; inactive; ]
InvDFTransform
:[font = text; inactive; ]
InvDFTransform[function, NumberOfPoints, FourierVariables,  TimeVariables, options] takes the inverse DFT of function,  where function is a function of FourierVariables defined from  0 to NumberOfPoints - 1.  Note that only the first two arguments  are required and that InvDFTransform calls InvDTFTransform. 
:[font = subsection; inactive; ]
InvDTFT
:[font = text; inactive; ]
InvDTFT[w, n] is the inverse discrete-time Fourier transform  operator.  Here, n is the time-domain variable(s), and w is the  frequency-domain variable(s).  Multidimensional inverse DTFT's are supported.  Applying TheFunction to the InvDTFT operator will invoke the  inverse DTFT rule base InvDTFTransform if loaded. 
:[font = subsection; inactive; ]
InvDTFTransform
:[font = text; inactive; ]
InvDTFTransform[function, in variable(s), out variable(s), options]  return the inverse discrete-time Fourier transform (inverse DTFT)  of the input function.  The first two arguments are required.  By default, the inverse DTFT rule base will apply the definition  of the inverse DTFT when all other attempts to find the inverse  have failed. 
:[font = subsection; inactive; ]
InvFT
:[font = text; inactive; ]
InvFT[w, t] is the inverse discrete Fourier transform operator.  Here, t is the time-domain variable(s) and w is the  frequency-domain variable(s).  Multidimensional Fourier transforms are supported.  Applying TheFunction to this operator will invoke the inverse  continuous-time Fourier transform rule base InvCTFTransform if loaded. 
:[font = subsection; inactive; ]
InvL
:[font = text; inactive; ]
InvL[s, t] is the inverse Laplace transform operator.  Applying TheFunction to the InvL operator will invoke the  bilateral inverse Laplace rule base InvLaPlace if loaded. 
:[font = subsection; inactive; ]
InvLaPlace
:[font = text; inactive; ]
InvLaPlace[f, s] and InvLaPlace[f, s, t] gives the multidimensional  bilateral inverse Laplace transform of f.  A region of convergence can be specified by using  InvLaPlace[ {f, rm, rp }, s, t], where rm is R- and rp is R+  in the region (strip) of convergence: R-  <  Re(s)  <  R+.  Note that InvLaPlaceTransform is an alias for InvLaPlace. 
:[font = subsection; inactive; ]
InvZ
:[font = text; inactive; ]
InvZ[z, n] is the inverse z-transform operator.  Applying TheFunction to the InvZ operator will invoke the inverse  z-transform rule base InvZTransform if loaded. 
:[font = subsection; inactive; ]
InvZTransform
:[font = text; inactive; ]
InvZTransform[e,z] or InvZTransform[e,z,n] gives the inverse  z-transform of e.  Here, e can be a function of z, a list, or  a z-transform object (see ZTransData).  As a list, e should  contain three elements:  F[z], rminus, and rplus, such that  the region of convergence is rminus  <   | z |   <  rplus.   If e is  a z-transform object, then the inverse z-transform is simply  InvZTransform[e] because e contains all necessary information.  If the returned expression is not the form you desire, then  apply Simplify[], Cancel[], Together[], etc., to the expression. 
:[font = subsection; inactive; ]
InvalidInvLTransformQ
:[font = text; inactive; ]
InvalidInvLTransformQ[trans] returns True if the inverse Laplace  transform rule base did not successfully finish the transform. 
:[font = subsection; inactive; ]
InvalidInvZTransformQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
InvalidLTransformQ
:[font = text; inactive; ]
InvalidLTransformQ[trans] returns True if the forward Laplace  transform rule base did not successfully finish the transform. 
:[font = subsection; inactive; ]
InvalidZTransformQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Irrational
:[font = text; inactive; ]
Irrational is an abstract data type.  See AssociateDataType. 
:[font = subsection; inactive; ]
IrrationalQ
:[font = text; inactive; ]
IrrationalQ[atom] returns True if the atom represents a number  which is irrational.  IrrationalQ[Pi] is True. 
:[font = subsection; inactive; ]
IsComplexQ
:[font = text; inactive; ]
IsComplexQ[expression] returns True if the expression could  be considered complex-valued.  IsComplexQ[1.0] is True. 
:[font = subsection; inactive; ]
IsImaginaryQ
:[font = text; inactive; ]
IsImaginaryQ[expression] returns True if the expression could  be considered imaginary. 
:[font = subsection; inactive; ]
IsIntegerQ
:[font = text; inactive; ]
IsIntegerQ[expression] returns True if the expression could  be considered integer-valued. 
:[font = subsection; inactive; ]
IsIrrationalQ
:[font = text; inactive; ]
IsIrrationalQ[expression] returns True if the expression could  be considered irrational. 
:[font = subsection; inactive; ]
IsRationalQ
:[font = text; inactive; ]
IsRationalQ[expression] returns True if the expression could  be considered rational.  IsRationalQ[1] is True. 
:[font = subsection; inactive; ]
IsRealQ
:[font = text; inactive; ]
IsRealQ[expression] returns True if the expression could  be considered real-valued. 
:[font = subsection; inactive; ]
KVariables
:[font = text; inactive; ]
KVariables is a data-tag for the DFT. 
:[font = subsection; inactive; ]
KeepNormalized
:[font = text; inactive; ]
KeepNormalized[zexpr, fun, zvars] keeps the z-transform  expression zexpr in negative powers of z after the function  fun is applied to zexpr.  If an optional fourth argument  is present, then the function fun[zexpr, z] is called instead  of fun[zexpr]. 
:[font = subsection; inactive; ]
L
:[font = text; inactive; ]
L[t, s] is the forward Laplace transform operator.  Applying TheFunction to the L operator will invoke the bilateral  Laplace rule base if loaded. 
:[font = subsection; inactive; ]
LForm
:[font = text; inactive; ]
LForm[transform] returns True if the transform is a valid  Laplace transform with a head of Transform or List. 
:[font = subsection; inactive; ]
LMultiDROC
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
LSolve
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
LTransData
:[font = text; inactive; ]
LTransData is a data tag for a valid Laplace transform object. 
:[font = subsection; inactive; ]
LTransformQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
LVariables
:[font = text; inactive; ]
LVariables is a data tag for variables in a Laplace transform object. 
:[font = subsection; inactive; ]
LaPlace
:[font = text; inactive; ]
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 bymultiplying the expression by CStep[t].  Also, LaPlaceTransform is an alias for LaPlace. 
:[font = subsection; inactive; ]
LineImpulse
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
LineImpulsemDT
:[font = text; inactive; ]
LineImpulsemDT[transq, expr, s, slist, nleft, fun] applies rules for  evaluating multidimensional transforms which involve line impulses,  like the z-transform of f[n1,n2] Impulse[n1 - n2] or the Laplace  transform of f[t1,t2] Delta[t1 - t2].  In the both cases, the  impulse can be removed by setting n1=n2 or t1=t2, which yields a  one-dimensional function.  The resulting 1D transform is then  altered by the rule z = z1 z2 or s = s1 + s2, respectively.  Here, the argument fun is Times for the z-transform and Plus for  the Laplace transform.  Note that these rules are only applied if  expr is a valid transform, which occurs if transq[expr] evaluates  to True. 
:[font = subsection; inactive; ]
Linear
:[font = text; inactive; ]
Linear is a possible value for axis scaling.  See MagPhasePlot. 
:[font = subsection; inactive; ]
ListQ
:[font = text; inactive; ]
ListQ[expr] gives True if expr is a List, and False otherwise. 
:[font = subsection; inactive; ]
Lowpass
:[font = text; inactive; ]
Lowpass describes a filter that passes all frequencies below  a cutoff frequency and rejects all others. 
:[font = subsection; inactive; ]
MagPhasePlot
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MagRangeScale
:[font = text; inactive; ]
MagRangeScale is an option for MagPhasePlot indicating the  scaling of the dependent variable axis, Linear or Log,  for the magnitude plot.  A setting of Null disables the generation of the phase plot. 
:[font = subsection; inactive; ]
MakeLObject
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MakeZObject
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MixedPolynomialQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MultT
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MultiDInvTransform
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MultiDTransform
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
MyApart
:[font = text; inactive; ]
MyApart[ rational polynomial, x ] decomposes the rational  polynomial into a sum of fractions whose numerators are of  the form (x + b) verb:^:n where b is a constant and n is an integer.  MyApart[rational polynomial, x, filter] specifies a filter to be  placed on the output of the Solve command used to root the  denominator:  Identity for rational and N for real-valued roots.  The default is Identity.  In Mathematica 1.2, MyApart is about 25 times slower than Apart. 
:[font = subsection; inactive; ]
MyCollectAll
:[font = text; inactive; ]
MyCollectAll[ expression, var ] attempts to collect all  subexpressions of expression in terms of var. 
:[font = subsection; inactive; ]
MyFreeQ
:[font = text; inactive; ]
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 .... 
:[font = subsection; inactive; ]
MyMessage
:[font = text; inactive; ]
MyMessage[message-label, return-value, arg1, arg2, ...] first calls  Message[message-label, arg1, arg2, ...] and then returns return-value. 
:[font = subsection; inactive; ]
MyTogether
:[font = text; inactive; ]
MyTogether[x] puts the expression x over a common denominator.  This is the same as Together[x] without the effect of Cancel.  This function is compatible with DFT expressions. 
:[font = subsection; inactive; ]
NegExponent
:[font = text; inactive; ]
NegExponent[poly, x] returns the maximum exponent of x verb:^:-1. 
:[font = subsection; inactive; ]
NormalizeSamplingMatrix
:[font = text; inactive; ]
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  }. 
:[font = subsection; inactive; ]
NormalizedQ
:[font = text; inactive; ]
NormalizedQ[e,x] gives True if the constant term is one  or zero, and gives False otherwise. 
:[font = subsection; inactive; ]
NullPlot
:[font = text; inactive; ]
NullPlot is a 2-d graphics object which only contains the origin. 
:[font = subsection; inactive; ]
OperatorInOperExpr
:[font = text; inactive; ]
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]] ]. 
:[font = subsection; inactive; ]
OperatorName
:[font = text; inactive; ]
OperatorName[ operator expression ] returns the head of the  expression.  For example, OperatorName[ Shift[2,n][x[n]] ] will return Shift. 
:[font = subsection; inactive; ]
ParametersInOperExpr
:[font = text; inactive; ]
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]] ]. 
:[font = subsection; inactive; ]
PatternQ
:[font = text; inactive; ]
PatternQ[expr] returns True if the head of expr is Pattern. 
:[font = subsection; inactive; ]
Periodic
:[font = text; inactive; ]
Periodic[k,n][f] indicates that f is a function of n which is  periodic with period of k. 
:[font = subsection; inactive; ]
PhaseRangeScale
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
PiecewiseConvolution
:[font = text; inactive; ]
PiecewiseConvolution[f, g, v] convolves the piecewise functions  f and g with respect to the variable t.  In this context, a function is represented in a piecewise fashion:  (1) as F-intervals of the form  {fun, left, right },  (2) as a list of F-intervals, or (3) as an expression.  An F-interval has the form  {function, left endpoint, right endpoint }.  The F-interval notation represents a finite-extent function or  sequence when the endpoints do not equal infinity.  The result of convolution is always returned as a list of F-intervals.  The variable v is treated as either discrete and continuous  according to the value of the Domain option.  The default domain is the value of   ConvolutionDomain,  which can be reset by the SetConvolutionDomain function.  See also CTPiecewiseConvolution and DTPiecewiseConvolution. 
:[font = subsection; inactive; ]
PlotList
:[font = text; inactive; ]
PlotList[l,  {v, vstart, vend }] plots the piecewise function l vs. v.  The variable v is treated as either discrete and continuous  according to the value of the Domain option.  The default domain is the value of   ConvolutionDomain. 
:[font = subsection; inactive; ]
PointwisePlot
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
PoleZeroPlot
:[font = text; inactive; ]
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 andshade the region of convergence (whenever the ROC does not cover theentire 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. 
:[font = subsection; inactive; ]
PolyphaseDownsample
:[font = text; inactive; ]
PolyphaseDownsample[m, n][x, h] is equivalent to downsampling  x by m and then convolving the result with h. 
:[font = subsection; inactive; ]
PolyphaseUpsample
:[font = text; inactive; ]
PolyphaseUpsample[l, n][x, h] is equivalent to upsampling  x by l and then convolving the result with h. 
:[font = subsection; inactive; ]
PrintIt
:[font = text; inactive; ]
PrintIt[graphics, printer] will print out graphics on a printer.  If the printer is not specified, the default printer is used. 
:[font = subsection; inactive; ]
ProtectIt
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Pulse
:[font = text; inactive; ]
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]. 
:[font = subsection; inactive; ]
ROCPlot
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Radian
:[font = text; inactive; ]
Radian is a possible value for axis scaling.  See MagPhasePlot. 
:[font = subsection; inactive; ]
RationalChebyshev
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
RationalFunctionQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
RationalGCD
:[font = text; inactive; ]
RationalGCD[list] returns the greatest common divisor of the  numerators in list divided by the greatest common divisor of  the denominators in list. 
:[font = subsection; inactive; ]
RationalPolynomialQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
RationalQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
RealQ
:[font = text; inactive; ]
RealQ[z] returns True if z is a floating-point number  (has a head of Real), False otherwise.  See RealValuedQ. 
:[font = subsection; inactive; ]
RealValuedQ
:[font = text; inactive; ]
RealValuedQ[z] gives True if z is a number whose imaginary  component is 0, and gives False otherwise.  See RealQ. 
:[font = subsection; inactive; ]
ReplaceWith
:[font = text; inactive; ]
ReplaceWith[oldexpr, newexpr] is a generalized way to specify  a substitution when the substitution may be either atomic  and a list of substitutions. 
:[font = subsection; inactive; ]
ResamplingMatrix
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ResamplingMatrixMod
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Rev
:[font = text; inactive; ]
Rev[n][x] represents the operation of reversing the direction of x,  with respect to the variables(s) n. 
:[font = subsection; inactive; ]
RightSided
:[font = text; inactive; ]
RightSided is an option for ZSolve.  If True, then the solution to the difference equation will be  right-sided, left-sided otherwise. 
:[font = subsection; inactive; ]
Rminus
:[font = text; inactive; ]
Rminus[  < r-minus >  ] is the head for the R- value in a transform. 
:[font = subsection; inactive; ]
RootLocus
:[font = text; inactive; ]
RootLocus[f(z), z,  {freeparam, start, end, step }] plots  the root locus of f(z) with respect to freeparam over the  range of start to end evaluated at increments of step.  RootLocus will generate three plots:  the pole zero plot for  freeparam = start, the root locus, and the pole-zero plot for  freeparam = end.  The function returns a list of all three plots.  RootLocus supports the same options as does Show.  RootLocusPlot is an alias of RootLocus. 
:[font = subsection; inactive; ]
Rplus
:[font = text; inactive; ]
Rplus[  < r-plus >  ] is the head for the R+ value in a transform. 
:[font = subsection; inactive; ]
SPLessGreaterRules
:[font = text; inactive; ]
SPLessGreaterRules are a collection of rules for simplifying  expressions involving inequalities. 
:[font = subsection; inactive; ]
SPSimplificationRules
:[font = text; inactive; ]
SPSimplificationRules are a collection of rules common in  simplifying formulas encountered in signal processing.  These rules require too much overhead to encode them directly  into Mathematica. 
:[font = subsection; inactive; ]
SPfunctions
:[font = text; inactive; ]
SPfunctions maintains a current list of those new routines  that have been loaded from the signal processing packages. 
:[font = subsection; inactive; ]
SPoperators
:[font = text; inactive; ]
SPoperators maintains a current list of the new mathematical  operators that have been loaded from the signal processing packages. 
:[font = subsection; inactive; ]
SPsignals
:[font = text; inactive; ]
SPsignals maintains a current list of those new signals  (mathematical functions) that have been loaded from the  signal processing packages. 
:[font = subsection; inactive; ]
SameFormQ
:[font = text; inactive; ]
SameFormQ[pattern, expr1, expr2, ...] returns True if every  expression matches pattern via MatchQ.  Once an expression does not match,  this function immediately returns False. 
:[font = subsection; inactive; ]
ScaleAxis
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ScaleT
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ScalingFactor
:[font = text; inactive; ]
ScalingFactor[expr, variable] returns the greatest common divisor  of all coefficients of powers of z in expr.  For example, ScalingFactor[ a z + a verb:^:2 z verb:^:2, z ] returns a.  This function enables the implementation of the similarity  property for transforms. 
:[font = subsection; inactive; ]
Second
:[font = text; inactive; ]
Second[list] returns the second element of list. 
:[font = subsection; inactive; ]
SequencePlot
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
SequenceToFunction
:[font = text; inactive; ]
SequenceToFunction[seq], SequenceToFunction[seq, n], and  SequenceToFunction[seq, n, noffset] return the sequence seq,   {x[noffset], ..., x[noffset + N - 1] }, in symbolic form as a sum of  impulse functions.  For example, SequenceToFunction[ {1, 2, 3 }] - >   Impulse[n] + 2 Impulse[n - 1] + 3 Impulse[n - 2].  For multidimensional sequences, the argument n must be a list of  variables of appropriate length.  For example, SequenceToFunction[ { {1,2 }, {3,4 } },  {n1, n2 }] - >   Impulse[n1,n2] + 2 Impulse[n1,n2-1] + 3 Impulse[n1-1,n2] +  4 Impulse[n1-1, n2-2]. 
:[font = subsection; inactive; ]
SetConvolutionDomain
:[font = text; inactive; ]
SetConvolutionDomain[domain] establishes the default convolution  domain as either Continuous or Discrete. 
:[font = subsection; inactive; ]
SetExclusion
:[font = text; inactive; ]
SetExclusion[set1, set2, ...] returns a set equal to the union  of the sets minus the intersection of the sets. 
:[font = subsection; inactive; ]
SetStateField
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ShadedAnnulus
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Shift
:[font = text; inactive; ]
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]. 
:[font = subsection; inactive; ]
SignalPlot
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
SignalsInOperExpr
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
SimplifyList
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Sinc
:[font = text; inactive; ]
Sinc[t] is the unit sinc function which is the ratio of  Sin[t] over t.  Note that Sinc[0] = 1. 
:[font = subsection; inactive; ]
SmithFormSameU
:[font = text; inactive; ]
SmithFormSameU[smithfun, m1, m2] computes the Smith Form of the  integer matrix m1 so that m1 = u1 d1 v1.  The routine then uses u2 = u1 to decompose m2.  The first argument specifies which decomposition routine should  be used to decompose m1 (e.g., SmithNormalForm).  The routine returns  {cond,  {u1 verb:^:-1, d1, v1 verb:^:-1 },  {u2 verb:^:-1, d2, v2 verb:^:-1 } },  where cond is True of False depending on whether or not matrices  m1 and m2 can be decomposed using the same U. 
:[font = subsection; inactive; ]
SmithFormSameV
:[font = text; inactive; ]
SmithFormSameV[smithfun, m1, m2] computes the Smith Form of the  integer matrix m1 so that m1 = u1 d1 v1.  The routine then uses v2 = v1 to decompose m2.  The first argument specifies which decomposition routine should  be used to decompose m1 (e.g., SmithNormalForm).  The routine returns  {cond,  {u1 verb:^:-1, d1, v1 verb:^:-1 },  {u2 verb:^:-1, d2, v2 verb:^:-1 } },  where cond is True of False depending on whether or not matrices  m1 and m2 can be decomposed using the same U. 
:[font = subsection; inactive; ]
SmithNormalForm
:[font = text; inactive; ]
SmithNormalForm[A] returns a list of three matrices  U verb:^:-1, D, and V verb:^:-1 such that the m x n resampling matrix A  equals U D V where U (m x m) and V (n x n) are integer matrices  with determinants of +1 or -1 and D is a diagonal matrix  of integer components such that  | det(D) |  =  | det(A) | .  The algorithm follows Kaufmann's  {Integer and Mixed Programming }.  Note that this factorization is not unique.  SmithNornamlForm supports a Dialogue option.  If True or All, SmithNormalForm will show immediate steps.  See also SmithOrderedForm and SmithReducedForm. 
:[font = subsection; inactive; ]
SmithOrderedForm
:[font = text; inactive; ]
SmithOrderedForm[A] returns a list of three matrices  U, D, and V such that the m x n resampling matrix A  equals U D V where U (m x m) and V (n x n) are integer matrices  with a determinant of 1 and D is a diagonal matrix  of integer components such that det(D) = det(A).  The components along the diagonal of D are sorted by absolute value.  The diagonal elements are positive except for possibly the  last one whose sign will be the sign of det(A).  Note that this factorization is unique if none of the diagonal  elements are equal in absolute value.  Also note that the starting point is the result of the Smith  Normal Form decomposition.  Like SmithNormalForm, SmithOrderedForm supports a Dialogue option.  If True or All, SmithNormalForm will show immediate steps.  See also SmithNormalForm and SmithReducedForm. 
:[font = subsection; inactive; ]
SmithReducedForm
:[font = text; inactive; ]
SmithReducedForm[A] returns a list of three matrices  U, D, and V such that the m x n resampling matrix A  equals U D V where U (m x m) and V (n x n) are integer matrices  with a determinant of +1 or -1 and D is a diagonal matrix  of positive integers such that  | det(D) |  =  | det(A) | .  Each component down the diagonal is a factor of the next one.  As a result, the diagonal elements are sorted down the diagonal.  The factorization is not unique.  Note that the starting point for this algorithm is the Smith  Ordered Form.  Like SmithOrderedForm, SmithReducedForm supports a Dialogue option.  If True or All, SmithNormalForm will show immediate steps.  See also SmithNormalForm and SmithOrderedForm. 
:[font = subsection; inactive; ]
Stable
:[font = text; inactive; ]
Stable[transexpr] returns True if the transform transexpr  represents a stable time-domain signal. 
:[font = subsection; inactive; ]
Start
:[font = text; inactive; ]
Start is a data-tag for the DFT. 
:[font = subsection; inactive; ]
Step
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
StripPackage
:[font = text; inactive; ]
StripPackage[symbol] returns the symbol (as a string) after its  context has been removed. 
:[font = subsection; inactive; ]
SubDataTypeQ
:[font = text; inactive; ]
SubDataTypeQ[expression, datatype] returns True if the data type  of expression could be coerced to datatype.  For example, SubDataTypeQ[5, Rational] is True, but  SubDataTypeQ[5.0, Rational] is False. 
:[font = subsection; inactive; ]
SubT
:[font = text; inactive; ]
SubT[transq, t1, t2] subtracts the transforms t2 from t1 and  determines the new region of convergence.  The resulting transform  is returned as a list.  SubT[transq, t1, t2, lowerlimit]  uses lowerlimit as the lower limit on the region of convergence  values when combining ROC's (default is 0). 
:[font = subsection; inactive; ]
SubTree
:[font = text; inactive; ]
SubTree[tree, head] returns the subtree with root head. 
:[font = subsection; inactive; ]
SubsetQ
:[font = text; inactive; ]
SubsetQ[set1, set2, set3,  ...] returns True if set1 is a subset  of set2 and set2 is a subset of set3, etc. 
:[font = subsection; inactive; ]
SubstituteForT
:[font = text; inactive; ]
SubstituteForT[transq, t, s, news] substitutes news at every  occurrence of s in the transform t.  The resulting transform  is returned as a list. 
:[font = subsection; inactive; ]
Summation
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
SymbolDataType
:[font = text; inactive; ]
SymbolDataType[symbol] returns the data type associated with  symbol or AllDataTypes if none exists. 
:[font = subsection; inactive; ]
SymbolDataTypeQ
:[font = text; inactive; ]
SymbolDataTypeQ[symbol, data-type] returns True if the symbol  is associated with the data type data-type.  Note that if a symbol is associated with Real,  then it is also associated with Integer and Rational as well. 
:[font = subsection; inactive; ]
TableLookup
:[font = text; inactive; ]
TableLookup[index, hlist, len, val] returns hlist[[index]]  if index is between 1 and len, inclusive; otherwise, val is  returned. 
:[font = subsection; inactive; ]
TheFunction
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
Third
:[font = text; inactive; ]
Third[list] returns the third element of list. 
:[font = subsection; inactive; ]
ToCollection
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
ToContinuous
:[font = text; inactive; ]
ToContinuous[expr] replaces any discrete operator or signal  in expr with its continuous equivalent. 
:[font = subsection; inactive; ]
ToDiscrete
:[font = text; inactive; ]
ToDiscrete[expr] replaces any continuous operator or signal  in expr with its discrete equivalent. 
:[font = subsection; inactive; ]
ToList
:[font = text; inactive; ]
ToList[arg] returns arg if arg is a list.  Otherwise, List[arg] is returned.  ToList[arg1, arg2, ...] returns List[arg1, arg2, ...]. 
:[font = subsection; inactive; ]
Transform
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
TransformFixUp
:[font = text; inactive; ]
TransformFixUp[transform, options, time var, transform var,  transform head, triplet flag, transform name, lower, upper]  attempts to resolve incomplete transforms according to the  transform pairs provided by the user via the TransformLookup option.  If the transform is a triplet of information (funct, Rminus, Rplus),  e.g. the forward z- and Laplace transforms, then triplet flag is True  and the lower and upper arguments are used for the second and  third fields of the triplet. 
:[font = subsection; inactive; ]
TransformLookup
:[font = text; inactive; ]
TransformLookup is an option for the transform rule bases.  It allows the user to specify a list of transform pairs to augment  those that already exist in the transform rule bases.  For example, ZTransform[ Shift[L, n][x[n]], n, z,  TransformLookup - >   { x[n] : >  X[z]  } ].This example allows the user to work x[n] without every defining it.  The multidimensional case is more tricky:  ZTransform[ x[n1, n2], n, z, TransformLookup - >    { x[n1, n2] : >  X[z1, n2], X[z1, n2] : >  X[z1, z2]  } ].  For the z- and Laplace transform rule bases, one can also specify  a region of convergence associated with the transform pairs. 
:[font = subsection; inactive; ]
UnAssociateDataType
:[font = text; inactive; ]
UnAssociateDataType[symbol] removes any association of that  that symbol with any data type.  UnAssociateDataType[symbol, datatype] removes the association  of symbol with datatype if one exists.  The function returns symbol.  See also AssociateDataType. 
:[font = subsection; inactive; ]
Unit
:[font = text; inactive; ]
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). 
:[font = subsection; inactive; ]
UnprotectIt
:[font = text; inactive; ]
UnprotectIt[expr] evaluates expr.  If it evaluates to a symbol,  write protection will be removed for that symbol. 
:[font = subsection; inactive; ]
Upsample
:[font = text; inactive; ]
Upsample[k,n][f] represents the upsampling operation on f,  which is either an expression of n or a squence (list) of values.  Upsampling inserts k-1 zeroes between every two samples.  In N dimensions, n is a list of N indices and k is an N x N matrix. 
:[font = subsection; inactive; ]
UpsampleFactor
:[font = text; inactive; ]
UpsampleFactor[f, n] returns the upsampling index.  If this routine returns 1, then no upsampling has occurred;  if it returns 0, then f is constant with respect to n. 
:[font = subsection; inactive; ]
UpsampleSequence
:[font = text; inactive; ]
UpsampleSequence[seq,m,fill] inserts m-1 fill values between  every two elements of seq. 
:[font = subsection; inactive; ]
UpsampledFunction
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ValidIntervalQ
:[font = text; inactive; ]
ValidIntervalQ[i] takes an F-interval i and  returns True if it is a meaningful representation of an interval  in either the domain specified by the Domain option or the  default domain   ConvolutionDomain if no Domain option is present.  Otherwise, it returns False. 
:[font = subsection; inactive; ]
VariableQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
WithinROC
:[font = text; inactive; ]
WithinROC[rm1,rp1,rm2,rp2] returns True if the interval [rm1,rp1]  is a subset of the interval [rm2,rp2]. 
:[font = subsection; inactive; ]
Z
:[font = text; inactive; ]
Z[n, z] is the forward z-transform operator.  Applying TheFunction to the Z operator will invoke the z-transform  rule base ZTransform if loaded. 
:[font = subsection; inactive; ]
ZForm
:[font = text; inactive; ]
ZForm[x] return True if the data packet x is tagged with  either List or Transform and contains three elements. 
:[font = subsection; inactive; ]
ZSolve
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ZTransData
:[font = text; inactive; ]
ZTransData is a data tag for a valid z-transform object. 
:[font = subsection; inactive; ]
ZTransform
:[font = text; inactive; ]
ZTransform[e,n] or ZTransform[e,n,z] gives the z-transform of  the expression e, which is a function of n, by returning an object  of three slots which is tagged by ZTransData:   < z-transform > ,  < rminus > ,  < rplus > , and  < z-variables > .  The Region of Convergence (ROC) is  < rminus >   <   | z |   <   < rplus > .  Note that the returned ROC is either the actual ROC or a subset  of the actual ROC.  In two dimensions, ZTransform[e,  {n1, n2 },  {z1, z2 }], is the same as  ZTransform [ ZTransform [e, n1, z1], n2, z2 ].  This notation extends naturally to higher dimensions. 
:[font = subsection; inactive; ]
ZTransformQ
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ZUpsampledQ
:[font = text; inactive; ]
ZUpsampledQ[f, n] returns True if the sequence f, as a function  of n, has been upsampled.  See UpsampleFactor. 
:[font = subsection; inactive; ]
ZVariables
:[font = text; inactive; ]
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. 
:[font = subsection; inactive; ]
ZeroQ
:[font = text; inactive; ]
ZeroQ[x] returns True if x is 0 or 0.0 
^*)