OP = OPBINARY(M,N,MODE) creates an M by N binary ensemble
    operator. When choosing MODE = 0 an explicit binary matrix is
    formed  and used when applying the operator. Choosing MODE = 1
    causes the operator to generate the above matrix on the fly,
    each time the operator is used. This mode can be used when
    dealing with very large matrices.

 
     OPBLOCKDIAG(WEIGHTS, OP1, OP2, ...) creates a compound
     operator with the given weighted operators on the diagonal;
     DIAG([WEIGHT1*OP1, WEIGHT2*OP2, ...]). The WEIGHT parameter is
     optional and can either be a scalar or a vector. In case of a
     scalar, all operators are weighted equally. If only a single
     operator is given it is replicated as many times as there are
     weights.
 
     See also opFoG, opKron, opWindowedOp, opDictionary.

 
    OPBLUR(M,N) creates an blurring operator for M by N
    images. This function is used for the GPSR-based test problems
    and is based on the implementation by Figueiredo, Nowak and
    Wright, 2007.
 
    This operator may soon be replaced by opConvolve2d.

 
     OPCOLUMNRESTRCIT(M,N,IDX,TYPE), with TYPE = 'DISCARD', creates
     an operator that extracts the columns indicated by IDX from a 
     given M by N matrix. The adjoint operator takes an M by
     length(IDX) matrix and outputs an M by N matrix with the
     columns filled by the given input matrix. Note that all input
     and output matrices are in vectorized from. When TYPE =
     'ZERO', all columns that are not in IDX are zero-padded
     instead of discarded.
 
     See also opMask, opRestriction.

 
     OPCONVOLVE1D(KERNEL,OFFSET,CIRCULAR) creates a one-dimensional
     convolution operator with the KERNEL function. The length of
     the KERNEL vector must coincide with the signal length. OFFSET
     gives the index in the KERNEL vector to be taken as its
     center and is set to 1 by default (i.e. no shifting). The
     CIRCULAR flag indicates whether the signal is periodic. If set
     to any non-zero value convolution is wrapped around the vector
     endpoints. By default CIRCULAR is set to 1.

 
     OPCURVELET2D(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 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.
 
     See also CURVELAB.

 
     OPDCT(N) creates a one-dimensional discrete cosine transform
     operator for vectors of length N.

 
     OPDIAG(N,D) creates an operator for N by N diagonal matrix
     multiplication. The diagonal is given by D which can be either
     a vector of length N or a scalar. OPDIAG(D) is a shortcut for
     OPDIAG(LENGTH(D),D) and can be used instead.

 
     OPDICTIONARY(WEIGHTS, OP1, OP2, ...) creates a dictionary
     operator consisting of the concatenation of all operators;
     [WEIGHT1*OP1 | WEIGHT2*OP2 | ...]. The WEIGHT parameter is
     optional and can either be a scalar or a vector. In case of a
     scalar, all operators are weighted equally.
 
     See also opFoG, opBLockDiag.

 
     OPDIRAC(N) creates the identity operator for vectors of length
     N. 

 
     OPFFT(N) create a one-dimensional normalized Fourier transform
     operator for vectors of length N.

 
     OPFFT2C(M,N) creates a two-dimensional normalized Fourier
     Transform that operates on matrices of size M by N. The
     components are shifted to have to zero-frequency component in
     the center of the spectrum. 

 
     OPFFT2D(M,N) creats 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.

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

 
     OPGAUSSIAN(M,N,MODE) creates an M by N Gaussian ensemble
     operator. By setting MODE a number of different types of
     ensemble can be generated; MODE = 0 (default) explicitly
     creates an unnormalized matrix from the Normal
     distribution. MODE = 1 generates columns of the unnormalized
     matrix as the operator is applied. This allows for much larger
     ensembles since the matrix is implicit. For MODE = 2,3 columns
     are scaled to have unit Euclidean norm, when MODE = 3 the
     matrix is implicit. For MODE 4,5,6 the rows are orthogonalized
     using respectively the QR, ORTH and SVD functions. For the
     last three modes matrices are always generated
     explicitly. The orthogonalization modes work only when M < N.

 
    OPHAAR(N,LEVELS) creates a Haar wavelet operator for one
    dimensional signal of length N. LEVELS indicates the number of
    scales to use, default is 5.
 
    See also opWavelet

 
    OPHAAR2D(N,LEVELS) creates a Haar wavelet operator for two
    dimensional signal of size M by N. LEVELS indicates the number of
    scales to use, default is 5.
 
    See also opWavelet

 
     OPHADAMARD(N,NORMALIZED) creates a Hadamard operator for
     vectors of length N. When N is not a power of two, vectors are
     internally padded by zeroes to the next power of
     two. Multiplication is done using a fast recursive
     implementation. When the normalized flag is set, the columns
     of the Hadamard matrix are scaled to unit two-norm. By default
     the NORMALIZED flag is set to 0.

 
     OPHEAVISIDE(N,S) creates an operator for multiplication by an
     N by N Heaviside matrix. These matrices have ones below and on
     the diagonal and zeros elsewhere. S is a flag indicating
     whether the columns should be scaled to unit Euclidean
     norm. By default the columns are unnormalized.

 
     OPKRON(OP1,OP2) creates an operator that is the Kronecker
     tensor product of OP1 and OP2.

 
     OPMASK(A) creates an operator that computes the dot-product of
     a given vector with the (binary) mask provided by A. If A is a
     matrix it will be vectorized prior to use.
 
     See also opColRestrict, opRestriction.

 
     OPMATRIX(A,OPINFO) creates an operator that performs
     matrix-vector multiplication with matrix A. Optional parameter
     OPINFO can be used to override the default operator
     information returned when querying the operator, or provide a 
     string giving the interpretation of the matrix. When OPINFO is
     a cell array the first entry is the operator name followed by
     additional information for that operator type (this option is
     mostly provided for internal use by other operators). 

 
    OPPADDING(SIZELHS,SIZERHS) create an operator that pads and
    unpads matrices equally around each size. SIZELHS and SIZERHS
    give the matrix size before and after padding. SIZERHS must
    be greater than or equal to SIZELHS, and both must have an even
    number of rows and columns.

 
     OPREAL(N) creates an operator that discards the imaginary
     components of input vectors of length N.

 
     OPRESTRICTION(N,IDX) creates a restriction operator that
     selects the entries listed in IDX from an input vector of
     length N. The adjoint of the operator creates a vector of
     length N and fills the entries given by IDX with the input
     data. 
 
     See also opColumnRestriction, opMask.

 
     OPSIGN(M,N,MODE) creates an M by N sign-ensemble operator. By
     setting MODE a number of different types of ensemble can be
     generated; MODE = 0 (default) explicitly creates an
     unnormalized matrix with random +1 and -1 entries. MODE = 1
     generates columns of the unnormalized matrix as the operator
     is applied. This allows for much larger ensembles since the
     matrix is implicit. For MODE = 2,3 columns are scaled to have
     unit Euclidean norm, when MODE = 3 the matrix is implicit.

 
     OPSPLITCOMPLEX(N) creates a nonlinear operator that splits a
     complex vector of length N into its real and imaginary parts
     [real(x); imag(x)]. In transpose mode it combines the real and
     imaginary parts into a complex vector.

 
     OPTRANSPOSE(OP) creates an operator that is the the adjoint
     operator OP.

 
     OPWAVELET(M,N,FAMILY,FILTER,LEVELS,TYPE) creates a wavelet
     operator of given FAMILY, for M by N matrices. The wavelet
     transformation is computed using the Rice Wavelet Toolbox.
 
     The remaining three parameters are optional. FILTER = 8
     specifies the filter length and must be even. LEVELS = 5 gives
     the number of levels in the transformation. Both M and N must
     be divisible by 2^LEVELS. TYPE = 'min' indictates what type of
     solution is desired; 'min' for minimum phase, 'max' for
     maximum phase, and 'mid' for mid-phase solutions. 

 
     OPWINDOWEDOP(M,OPERATOR,WINDOW,OVERLAP) creates an
     overcomplete windowed operator with overlap:
 
       /  +------------+-------------------------+
      |   |            |                         |
      |   | Diag(W)*OP |                         |
      |   |            +------------+            | --
   M  /   +------------+            |            | -- OVERLAP
      \   |            | Diag(W)*OP |            |
      |   |            |            +------------+
      |   |            +------------+            |
      |   |                         | Diag(W)*OP |
       \  +-------------------------+------------+
     
     with W for WINDOW and OP for OPERATOR.
 
     Parameter OVERLAP must be strictly less than the length of
     WINDOW, which in turn must coincide with the number of rows
     in the OPERATOR. M indicates the signal length and prescribes
     the number of rows in the resulting operator. The number of
     columns is always an integer multiple of the number of columns
     in OPERATOR and depends on the required number of blocks.