# Index of Operators

M-File Help: opBernoulli
opBernoulli
``` opBernoulli   Bernoulli-ensemble operator.

opBernoulli(M,N) creates an M-by-N Bernoulli ensemble, a matrix
with iid +1/-1 entries.

opBernoulli(M) creates a square M-by-M Bernoulli ensemble.

opBernoulli(M,N,MODE) is the same as above, except that the
parameter MODE controls the type of ensemble that is generated.
The default is MODE=0 unless the overall memory requred exceeds 50
MBs.

MODE = 0 (default): generates an explicit unnormalized matrix with
random +1/-1 entries. The overall storage is O(M*N).

MODE = 1: generates columns of the unnormalized matrix as the
operator is applied. This allows for much larger ensembles since
the matrix is implicit. The overall storage is O(M).

MODE = 2: generates a scaled explicit matrix with unit-norm
columns.

MODE = 3: same as MODE=2, but the matrix is implicit (see MODE=1).

Available operator properties:
.mode  gives the mode used to create the operator.```
M-File Help: opBinary
opBinary
``` opBinary   Binary (0/1) ensemble.

opBinary(M,N) creates an M-by-N binary-ensemble operator.

opBinary(M) creates a square M-by-M binary-ensemble.

opGaussian(M,N,MODE) is the same as above, except that the
parameter MODE controls the type of ensemble that is generated.
The default is MODE=0 unless the overall memory requred exceeds 50
MBs.

MODE = 0 (default): generates an explicit matrix with O(M*N)
storage.

MODE = 1: generates columns of the matrix as the operator is
applied. This allows for much larger ensembles because the matrix
is stored implicitly. The overall storage is O(M).```
M-File Help: opBlockDiag
opBlockDiag
``` opBlockDiag   Operator-diagonal operator.

B = opBlockDiag(OP1, OP2,...,OPN,OVERLAP) creates a compound block
operator with the input operators OP1, OP2,... on the diagonal of
B, e.g., B = DIAG([OP1 OP2 ... OPN]). When OVERLAP is a positive
integer the blocks will be offset OVERLAP rows relative to the
previous operator, when OVERLAP is negative the operators are
offset by the absolute value of OVERLAP in columns. Note that
choosing OVERLAP larger than the operator size may cause the
matrix to become block antidiagonal.

weights each block by the elements of the vector WEIGHT. If
only a single operator is given it is replicated as many times
as there are weights.

B = opBlockDiag(N,OP,OVERLAP) similar as above with WEIGHT
equal to ones(N,1). This will cause operator OP to be repeated
N times.```
M-File Help: opBlockOp
opBlockOp
``` opBlockOp   Blockwise application of operator on matrices.

B = opBlockOp(M,N,OPIN,BR1,BC1,BR2,BC2) creates an operator that
applies the given OPIN operator on two-dimensional data in a
blockwise fashion. In the forward mode this means that the input
vector is reshaped into an M-by-N matrix, which is then divided
into blocks of size BR1-by-BC1. Next, we apply OPIN to each
(vectorized) block and reshape the output to BR2-by-BC2
blocks. These blocks are gathered in a matrix which is vectorized
to give the final output. In transpose mode, the input vector is
reshaped into a matrix with M/BR1-by-N/BC1 blocks of size
BR2-by-BC2, and the conjugate transpose of OPIN is applied to each
block as described above to give BR1-by-BC1 blocks. These form an
M-by-N matrix which is vectorized for output. When omitted, BR2
and BC2 are respectively set to BR1 and BC1 by default.```
M-File Help: opCTranspose
opCTranspose
``` opCTranspose   Conjugate transpose of an operator.

opCTranspose(OP) returns the conjugate tranpose of OP.```
M-File Help: opChol
opChol
``` opCHOL  Operator representing the Cholesky factorization of a
symmetric and definite matrix with optional iterative
refinement. Only the lower triangle of the input matrix
is referenced.

opChol(A) creates an operator for multiplication by the
inverse of the matrix A implicitly represented by its Cholesky
factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)

Copyright 2009, Ewout van den Berg and Michael P. Friedlander
See the file COPYING.txt for full copyright information.
Use the command 'spot.gpl' to locate this file.```
M-File Help: opClass
opClass
``` opClass   Wrapper for classes.

opClass(M,N,OBJ,CFLAG,LINFLAG) creates an M by N wrapper operator
for the class instance OBJ. The only requirement on OBJ is that it
implements the `mtimes' method. Optional arguments CFLAG and LINFLAG
indicate whether the class implements a complex or real operator and
whether it is linear or not. By default these fields are set to
CFLAG=0, LINFLAG=1.```
M-File Help: opConj
opConj
``` opConj   Take the elementwise conjugate of a complex operator.

opConj(OP) is the elementwise complex conjugate of operator
OP. Applying opConj to conjugate operators returns the original
operator.```
M-File Help: opConvolve
opConvolve
``` opConvolve   One and two dimensional convolution operator.

opConvolve(M,N,KERNEL,OFFSET,MODE) creates an operator for one or
two-dimensional convolution, depending on the size of the KERNEL,
and the matrix or vector (MxN) the convolution is applied to. The
convolution is one dimensional only if KERNEL is a column vector
and N=1, or KERNEL is a row vector and M=1. The OFFSET parameter
determines the center of the KERNEL and has a default value of
[1,1]. When the OFFSET lies outside the size of the KERNEL, the
KERNEL is embedded in a zero matrix/vector with appropriate
center. For one-dimensional convolution, KERNEL may be a
scalar. Specifying an offset that is not equal to one where the
corresponding size of the kernel does equal one leads to the
construction of a two-dimensional convolution operator. There are
three types of MODE:

MODE = 'regular'   - convolve input with kernel;
'truncated' - convolve input with kernel, but keep only
those MxN entries in the result that
overlap with the input;
'cyclic'    - do cyclic convolution of the input with a
kernel that is wrapped around as many
times as needed.

The output of the convolution operator, like all other
operators, is in vector form.```
M-File Help: opCurvelet
opCurvelet
``` opCurvelet  Two-dimensional curvelet operator.

opCurvelet(M,N,NBSCALES,NBANGLES,TTYPE) creates a two-dimensional
curvelet operator for M by N matrices. The curvelet transform is
computed using the Curvelab code.

The remaining three parameters are optional; NBSCALES gives the
number of scales and is set to max(1,ceil(log2(min(M,N)) - 3)) by
default, as suggested by Curvelab. NBANGLES gives the number of
angles at the second coarsest level which must be a multiple of
four with a minimum of 8. By default NBANGLES is set to 16. TTYPE
determines the type of transformation and is set to 'WRAP' by
default.```
M-File Help: opDCT
opDCT
``` opDCT  Discrete cosine transform (DCT).

opDCT(M) creates a one-dimensional discrete cosine transform
operator for vectors of length M.```
M-File Help: opDCT2
opDCT2
``` opDCT2  Two-dimensional discrete cosine transform (DCT).

opDCT2(M,N) creates a two-dimensional discrete cosine transform
operator for matrices of size M-by-N. Input and output of the
matrices is done in vectorized form. When N is omitted it is set
to M by default.```
M-File Help: opDFT
opDFT
``` opDFT  Fast Fourier transform (DFT).

opDFT(M) create a unitary one-dimensional discrete Fourier
transform (DFT) for vectors of length M.

opDFT(M,CENTERED), with the CENTERED flag set to true, creates a
unitary DFT that shifts the zero-frequency component to the center
of the spectrum.```
M-File Help: opDFT2
opDFT2
``` opDFT2  Two-dimensional fast Fourier transform (DFT).

opDFT2(M,N) creates a two-dimensional normalized Fourier transform
operator for matrices of size M by N. Input and output of the
matrices is done in vectorized form.

opDFT2(M,N,CENTERED) just like opDFT2(M,N), but with components
shifted to have to zero-frequency component in the center of the
spectrum, if the CENTERED flag is set to true.```
M-File Help: opDiag
opDiag
``` opDiag   Diagonal operator.

opDiag(D) creates an operator for multiplication by the
diagonal matrix that has a vector D on its diagonal.```
M-File Help: opDictionary
opDictionary
``` opDictionary   Dictionary of concatenated operators.

D = opDictionary(OP1,OP2,...OPn) creates a dictionary
operator consisting of the concatenation of all operators, i.e.,

D = [ OP1, OP2, ..., OPn ].

In general, it's best to use Matlab's horizonal concatenation
operations instead of calling opDictionary. (The two are equivalent.)```
M-File Help: opDirac
opDirac
``` opDirac  Dirac basis.

opDirac(N) creates the square N-by-N identity operator. Without
any arguments an operator corresponding to the scalar 1 is
created.```
M-File Help: opEmpty
opEmpty
``` opEmpty   Operator equivalent to empty matrix.

opEmpty(M,N) creates an operator corresponding to an empty M-by-N
matrix. At least one of M and N must be zero.```
M-File Help: opExcise
opExcise
``` opExcise   Excise rows or columns of an operator.

opExcise(OP,IDX,TYPE) excises the entries in the rows or columns
given by IDX, depending on whether TYPE = 'rows', or 'cols'.```
M-File Help: opExtend
opExtend
``` opExtend   Symmetric extension operator.

opExtend(P,Q,PEXT,QEXT) creates an extension operator that acts on a
"vectorized" matrix and appends a mirror symmetric boundary to the
right and bottom portions of  matrix. The original matrix is of size
PxQ. The operator generates a matrix that is PEXTxQEXT matrix. The
adjoint of the operator creates a PxQ matrix whose entries adjacent to
the extension border are twice the value of the entries of the original
matrix.

Q      QEXT
*************++++++
*           *     +
*           *     +
*           *     +
P *************     +
+                 +
PEXT +++++++++++++++++++

Example 1. Extend a 2-by-3 matrix into a 4-by-6 matrix:
A = [1 2 3; 4 5 6];
E = opExtend(2, 3, 4, 6);
reshape(E*A(:),4,6)

Example 2. Requires imaging toolbox:
E = opExtend(256,256,650,1400);
Isup = reshape(E*I(:),650,1400);
figure; imshow(uint8(Isup));```
M-File Help: opEye
opEye
``` opEye  Identity operator.

opEye(M) creates the M-by-M identity operator.

opEye(M,N) creates the M-by-N identity operator. If N is omitted
it is set to M by default. Without any arguments an operator
corresponding to the scalar 1 is created.

opEye([M N]) is the same as the above.```
M-File Help: opFactorization
opFactorization
``` opFactorization  Operator representing an inverse by way of a factorization.
Useful to avoid multiple factorizations as in opInverse
and save time by performing only forward and backsolves.```
M-File Help: opFoG
opFoG
``` opFoG   Forms the product of two operators.

opFoG(OP1,OP2) creates an operator that successively applies each
of the operators OP1, OP2 on a given input vector. In non-adjoint
mode this is done in reverse order.

The inputs must be either Spot operators or explicit Matlab matrices
(including scalars).```
M-File Help: opFunction
opFunction
``` opFunction   Wrapper for functions.

opFunction(M,N,FUN) creates a wrapper for function FUN, which
corresponds to an M-by-N operator. The FUN parameter can be one of two
types:

1) A handle to a function of the form FUN(X,MODE), where the
operator is applied to X when MODE = 1, and the transpose is applied
when MODE = 2;
2) A cell array of two function handles: {FUN,FUN_TRANSPOSE},
each of which requires only one parameter, X.

CFLAG and LINFLAG to indicate whether the function implements a complex
or real operator and whether it is linear or not. The default values
are CFLAG=0, LINFLAG=1.```
M-File Help: opGaussian
opGaussian
``` opGaussian   Gaussian ensemble.

opGaussian(M,N) creates an M-by-N Gaussian-ensemble operator.

opGaussian(M) creates a square M-by-M Gaussian-ensemble.

opGaussian(M,N,MODE) is the same as above, except that the
parameter MODE controls the type of ensemble that is generated.
The default is MODE=0 unless the overall memory requred exceeds 50
MBs.

MODE = 0 (default): generates an explicit unnormalized matrix from
the Normal distribution. The overall storage is O(M*N).

MODE = 1: generates columns of the unnormalized matrix as the
operator is applied. This allows for much larger ensembles because
the matrix is implicit. The overall storage is O(M).

MODE = 2: generates a explicit matrix with unit-norm columns.

MODE = 3: same as MODE=2, but the matrix is implicit (see MODE=1).

MODE = 4: generates an explicit matrix with orthonormal rows.
This mode requires M <= N.

Available operator properties:
.mode  is the mode used to create the operator.
.seed  is the seed used to initialize the RNG.```
M-File Help: opHaar
opHaar
``` opHaar   Haar wavelet.

opHaar(N) creates a Haar Wavelet operator for 1-D signals of
length N using 5 levels. N must be a power of 2.

opHaar(N,LEVELS) optionally allows the number of LEVELS to be
specified.

opHaar(N,LEVELS,REDUNDANT) optionally specifies the boolean field
REDUNDANT (default false).  (See opWavelet for a description of this
option.)```
M-File Help: opHaar2
opHaar2
``` opHaar2   2-D Haar Wavelet.

opHaar2(M,N) creates a Haar Wavelet operator for 2-D signals of
size M-by-N using 5 levels. M*N must be a power of 2.

opHaar2(M,N,LEVELS) optionally allows the number of LEVELS to be
specified.

opHaar2(M,N,LEVELS,REDUNDANT) optionally specifies the boolean field
REDUNDANT (default false).  (See opWavelet for a description of this
option.)```
``` opHadamard   Hadamard matrix.

N, where N is a power of two. Multiplication is done using a fast
routine.

opHadamard(N,NORMALIZED) is the same as above, except that the
columns are scaled to unit two-norm. By default, the NORMALIZED
flag is set to FALSE.```
M-File Help: opHeaviside
opHeaviside
``` opHeaviside   Heaviside operator.

opHeaviside(N,NORMALIZED) creates an operator for multiplication
by an N by N Heaviside matrix. These matrices have ones below and
on the diagonal and zeros elsewhere. NORMALIZED is a flag
indicating whether the columns should be scaled to unit Euclidean
norm. By default the columns are unnormalized.```
M-File Help: opHermitian
opHermitian
``` opHermitian   Convert a numeric matrix stored as its lower triangle
into a Spot operator.

opHermitian(A,DESCRIPTION) creates a hermitian operator that performs
matrix-vector multiplication with matrix A. Only the lower triangle of
the input matrix need to be stored. The optional parameter
DESCRIPTION can be used to override the default operator name when
printed.```
M-File Help: opImag
opImag
``` opImag   Complex imaginary part of operator.

opImag(OP) is the complex imaginary part of operator OP. Note
that the resulting operator is real.```
M-File Help: opInverse
opInverse
``` opInverse   (Pseudo) inverse of operator.

Ainv = opInverse(A) creates the (pseudo) inverse of a square operator.
The product Ainv*b is then equivalent to A\b.```
M-File Help: opKron
opKron
``` opKron   Kronecker tensor product.

opKron(OP1,OP2,...OPn) creates an operator that is the Kronecker
tensor product of OP1, OP2, ..., OPn.```
M-File Help: opLDL
opLDL
``` opLDL   Operator representing the LDL factorization of a symmetric
matrix with optional iterative refinement. Only the lower
triangle of the input matrix is referenced. This is currently
only available for real matrices. If the matrix
is known to be definite, opChol will be more efficient.

opLDL(A) creates an operator for multiplication by the
inverse of the matrix A implicitly represented by its LDL
factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)

Copyright 2009, Ewout van den Berg and Michael P. Friedlander
See the file COPYING.txt for full copyright information.
Use the command 'spot.gpl' to locate this file.```
M-File Help: opLU
opLU
``` opLU    Operator representing the LU factorization of a
matrix with optional iterative refinement. If the matrix
is known to be symmetric, opLDL will be more efficient.
If in addition, the matrix is known to be definite,
opChol will be more efficient.

opLU(A) creates an operator for multiplication by the (pseudo-)
inverse of the matrix A implicitly represented by its LU
factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)

Copyright 2009, Ewout van den Berg and Michael P. Friedlander
See the file COPYING.txt for full copyright information.
Use the command 'spot.gpl' to locate this file.```
``` opMask  Selection mask.

opMask(N,IDX) creates a diagonal N-by-N operator that has ones
only on those locations indicated by IDX.

IDX is logical.```
M-File Help: opMatrix
opMatrix
``` opMatrix   Convert a numeric matrix into a Spot operator.

opMatrix(A,DESCRIPTION) creates an operator that performs
matrix-vector multiplication with matrix A. The optional parameter
DESCRIPTION can be used to override the default operator name when
printed.```
M-File Help: opMinus
opMinus
``` opMinus   Difference of two operators.

opMinus(OP1,OP2) creates a compound operator representing OP1-OP2.```
M-File Help: opOnes
opOnes
``` opOnes   Operator equivalent to ones function.

opOnes(M,N) creates an operator corresponding to an M by N matrix
of ones. If parameter N is omitted it is set to M.```
M-File Help: opOrthogonal
opOrthogonal
``` opOrthogonal   Abstract class for orthogonal operators.

opOrthogonal methods:
opOrthogonal - constructor
mldivide     - solves Ax=b  via  x=A'b.```
M-File Help: opPInverse
opPInverse
``` opPInverse   Pseudo inverse of operator.

Apinv = opPInverse(A) creates the pseudo inverse of a M-by-N
operator A. The product Apinv*b is then equivalent to A\b.```
M-File Help: opPermutation
opPermutation
``` opPermutation   Permutation operator.

P = opPermutation(p) creates a permutation operator from a permutation
vector. The product P*b is then equivalent to b(p).

M-File Help: opPower
opPower
``` opPower   Raise operator to integer power.

opPower(OP,P) creates the operator OP^P for integer values of
P. When P = 0, the identity matrix is returned. When P < 0 we
reformulate the operator as inv(OP^|P|).```
M-File Help: opQR
opQR
``` opQR    Operator representing the QR factorization of a
matrix with optional iterative refinement. If the matrix

opQR(A) creates an operator for multiplication by the (pseudo-)
inverse of the matrix A implicitly represented by its QR
factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)

Copyright 2009, Ewout van den Berg and Michael P. Friedlander
See the file COPYING.txt for full copyright information.
Use the command 'spot.gpl' to locate this file.```
M-File Help: opReal
opReal
``` opReal   Real part of operator.

opReal(OP) is the real part of operator OP.```
M-File Help: opRestriction
opRestriction
``` opRestriction   Restriction operator.

opRestriction(N,IDX) creates a restriction operator that selects
the entries listed in the index vector IDX from an input vector of
length N. The adjoint of the operator creates a zero vector of
length N and fills the entries given by IDX with the input data.

Algebraically, opRestriction(N,IDX) is equivalent to a matrix of
size length(IDX)-by-N, where row i has a single 1 in column
IDX(i).```
M-File Help: opSparseBinary
opSparseBinary
``` opSparseBinary   Random sparse binary matrix.

opSparseBinary(M,N) creates an M-by-N sparse binary matrix with
min(M,8) nonzeros in each column.

opSparseBinary(M,N,D) is the same as above, except that each
column has min(M,D) nonzero elements.

This matrix was suggested by Radu Berinde and Piotr Indyk,
"Sparse recovery using sparse random matrices", MIT CSAIL TR
2008-001, January 2008, http://hdl.handle.net/1721.1/40089

Note that opSparseBinary calls RANDPERM and thus changes the state
of RAND.```
M-File Help: opStack
opStack
``` opStack  Stack of vertically concatenated operators.

opStack(WEIGHTS, OP1, OP2, ...) creates a stacked
operator consisting of the vertical concatenation of all
operators;

[WEIGHT1*OP1
WEIGHT2*OP2
...
WEIGHTn*OPn]

If the same weight is to be applied to each operator, set
WEIGHTS to a scalar. When WEIGHTS is empty [], it is set to
one. The WEIGHT parameter can be omitted as long as OP1 is not
a vector of length (n-1); in which case there is no way to
decide whether it is a weight vector or operator.```
M-File Help: opSubsAsgn
opSubsAsgn
``` opSubsAsgn   Redefine rectangular subset of operator.

opSubsAsign(A,ROWIDX,COLIDX,B), index = ':' is valid. Size of B
must match that of rowidx and colidx. THe indices can exceed the
size of A (even if idx is given as logical) but must not be negative?```
M-File Help: opSubsRef
opSubsRef
``` opSubsRef   Extract rectangular subset of operator entries.

opSubsRef(OP,ROWIDX,COLIDX) returns subset of entries indicated by
the ROWIDX and COLIDX. The indices are either integer or logical
vectors, or the ':' string denoting the entire range.```
M-File Help: opSum
opSum
``` opSum   Addition of two operators.

opSum(A,B) creates a compound operator representing (A + B).```
M-File Help: opToepGauss
opToepGauss
``` opToepGauss  Toeplitz matrix with Gaussian entries.

OP = opToepGauss(M,N,TYPE,NORMALIZED) creates an M by N Toeplitz
matrix with Gaussian entries. TYPE can either be 'toeplitz' or
'circular'. For the 'toeplitz' type matrix, m+n-1 different
generating entries are generated at random, whereas for the
'circular' matrix, only max(m,n) are needed. When the TYPE field
is empty [], or not specified 'toeplitz' is chosen by
default. Setting the NORMALIZED flag scales the columns of the
Toeplitz matrix to unit norm. Multiplication is implemented using
the fast Fourier transform. The use of such matrices in compressed
sensing was suggested by:

 W. U. Bajwa, J. D. Haupt, G. M. Raz, S. J. Wright, and
R. D. Nowak, Toeplitz-Structured Compressed Sensing Matrices,
IEEE/SP 14th Workshop on Statistical Signal Processing,
pp. 294-298, August 2007.```
M-File Help: opToepSign
opToepSign
``` opToepSign  Toeplitz matrix with random sign entries.

OP = opToepSign(M,N,TYPE,NORMALIZED) creates an M by N Toeplitz
matrix with random +1 and -1 entries. TYPE can either be
'toeplitz' or 'circular'. For the 'toeplitz' type matrix, m+n-1
different generating entries are generated at random, whereas for
the 'circular' matrix, only max(m,n) are needed. When the TYPE
field is empty [], or not specified 'toeplitz' is chosen by
default. Setting the NORMALIZED flag scales the columns of the
Toeplitz matrix to unit norm.  Multiplication is implemented using
the fast Fourier transform. The use of such matrices in compressed
sensing was suggested by:

 W. U. Bajwa, J. D. Haupt, G. M. Raz, S. J. Wright, and
R. D. Nowak, Toeplitz-Structured Compressed Sensing Matrices,
IEEE/SP 14th Workshop on Statistical Signal Processing,
pp. 294-298, August 2007.```
M-File Help: opToeplitz
opToeplitz
``` opToeplitz   Toeplitz matrix.

OP = opToeplitz(R) creates an N-by-N circular Toeplitz
operator from the N-vector R. The entries of R prescribe the
first row of the operator.

OP = opToeplitz(C,R) creates an M-by-N Toeplitz operator where
M = length(C) and N = length(R). The entries of C prescribe the
first column of the operator, and likewise, R prescribes the
first row.

The above calls are nearly idential to Matlab's built-in TOEPLITZ
function.

Additionally, each call above accepts an optional logical flag that
indicates if the column are scaled to have unit 2-norm length:

OP = opToeplitz(R,NORMALIZED)
OP = opToeplitz(C,R,NORMALIZED)

Multiplication in either mode is implemented using the fast
Fourier transform```
M-File Help: opTranspose
opTranspose
``` opTranspose   Transpose of an operator.

opTranspose(OP) returns the tranpose of OP.```
M-File Help: opUnaryMinus
opUnaryMinus
``` opUnaryMinus   Negation of an operator.

opUnaryMinus(OP) returns -OP.```
M-File Help: opWavelet
opWavelet
``` opWavelet   Wavelet operator.

opWavelet(N) creates a Wavelet transform for 1-dimensional signals
of size N.  The wavelet transformation is computed using the Rice
Wavelet Toolbox.

opWavelet(N,FAMILY) additionally specifies the FAMILY for the
wavelet. Supported values for FAMILY are 'Daubechies' and 'Haar'.

opWavelet(N,FAMILY,FILTER,LEVELS,REDUNDANT,TYPE) allows for four
additional parameters: FILTER (default 8) specifies the filter
length, which must be even. LEVELS (default 5) gives the number of
levels in the transformation. P does not need to be divisible by
2^LEVELS. However, if LEVELS is bigger than LOG2(P), then LEVELS is
adjusted to be equal to FLOOR(LOG2(P)). The Boolean field REDUNDANT
(default false) indicates whether the wavelet is redundant. TYPE
(default 'min') indictates what type of solution is desired; 'min'
for minimum phase, 'max' for maximum phase, and 'mid' for mid-phase
solutions.

The opWavelet operator is linear but not orthogonal. Therefore, the
transpose of the operator is not the inverse operator. However, the
inverse of the operator can be obtained through a left-inverse
operation. For example:
W = opWavelet(...)
y = W*x
if z = W'*y, then z ~= x
but, u = W\y, then u = x```
M-File Help: opWavelet2
opWavelet2
``` OPWAVELET   Wavelet operator.

opWavelet(P,Q,FAMILY) creates a Wavelet operator of given FAMILY for
signals of size P-by-Q. The wavelet transformation is computed using
the Rice Wavelet Toolbox.  The values supported for FAMILY are
'Daubechies' and 'Haar'.

opWavelet(P,Q,FAMILY,FILTER,LEVELS,REDUNDANT,TYPE) allows for four
additional parameters: FILTER (default 8) specifies the filter length,
which must be even. LEVELS (default 5) gives the number of levels in
the transformation. P and Q do not need to be divisible by 2^LEVELS.
However, if LEVELS is bigger than LOG2(MIN(P,Q)), then LEVELS is
adjusted to be equal to FLOOR(LOG2(MIN(P,Q))).
The Boolean field REDUNDANT (default false) indicates whether the wavelet
is redundant. TYPE (default 'min') indictates what type of solution is
desired; 'min' for minimum phase, 'max' for maximum phase, and 'mid'
for mid-phase solutions.

The opWavelet operator is linear but not orthogonal. Therefore, the
transpose of the operator is not the inverse operator. However, the
inverse of the operator can be obtained through a left-inverse
operation. For example:
W = opWavelet(...)
y = W*x
if z = W'*y, then z ~= x
but, u = W\y, then u = x```
M-File Help: opWindow
opWindow
``` opWindow   Diagonal window matrix.

opWindow(D) creates an operator for multiplication by the
diagonal matrix with D on its diagonal.

opWindow(N,FAMILY,VARARGIN) creates an N by N diagonal matrix with
diagonal entries given by the window function of given family and

Family                 Optional parameters
---------------------  ----------------------------------------
Bartlett               -
Bartlett-Hann          -
Blackman               alpha = 0.16;
Blackman-Harris        -
Blackman-Nuttall       -
Bohman                 -
Cauchy                 alpha = 3;
Cos                    (see Cosine)
Cosine                 alpha = 1;
Dirichlet              -
Flattop                -
Gauss                  (see Gaussian)
Gaussian               alpha = 2.5;
Hamming                -
Hann                   -
Hann-Poisson           alpha = 1;
Kaiser                 alpha = 0.5;
Kaiser-Bessel Derived  alpha = 0.5;
KBD                    (see Kaiser-Bessel Derived)
Lanczos                alpha = 1;
Triangle               -
Parzen                 -
Poisson                alpha = 1;
Rectangle              (see Dirichlet)
Sinc                   (see Lanczos)
Tukey                  alpha = 0.5;
Uniform                (see Dirichlet)
Valle-Poussin          (see Parzen)
Weierstrasss           (see Gaussian)```
M-File Help: opZeros
opZeros
``` opZeros   Operator equivalent to zeros function.

opZeros(M,N) creates an operator corresponding to an M-by-N matrix
of zeros. If parameter N is omitted it is set to M.```
M-File Help: opiChol
opiChol
``` opiChol   Operator representing the incomplete Cholesky factorization of a
symmetric and definitematrix with optional iterative refinement.

opiChol(A) creates an operator for multiplication by an approximate
inverse of the matrix A implicitly represented by its incomplete
Cholesky factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

Additional input arguments are passed directly to ichol() with the
exception of the 'shape' attribute.

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)

Copyright 2009, Ewout van den Berg and Michael P. Friedlander
See the file COPYING.txt for full copyright information.
Use the command 'spot.gpl' to locate this file.```
M-File Help: opiLU
opiLU
``` opiLU   Operator representing the incomplete LU factorization of a
matrix with optional iterative refinement. If the matrix
is known to be symmetric and definite, opiChol will be more
efficient.

opiLU(A) creates an operator for multiplication by an approximate
inverse of the matrix A implicitly represented by its incomplete LU
factorization. Optionally, iterative refinement is performed.
Note that A is an explicit matrix.

Additional input arguments are passed directly to ilu().

The following attributes may be changed by the user:
* nitref : the maximum number of iterative refinement steps (3)
* itref_tol : iterative refinement tolerance (1.0e-8)
* force_itref : force iterative refinement (false)