# Index of Methods

M-File Help: opSpot/bicg
opSpot/bicg
``` BICG   BiConjugate Gradients Method.

X = bicg(A,B) attempts to solve the linear system A*X=B via the
BICG method.

This routine is simply a wrapper to Matlab's own BICGS routine,
and the argument list variations described in Matlab's BICG
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/bicgstab
opSpot/bicgstab
``` BICGSTAB   BiConjugate Gradients Stabilized Method.

X = bicgstab(A,B) attempts to solve the linear system A*X=B via
the BICGSTAB method.

This routine is simply a wrapper to Matlab's own BICGSTAB routine,
and the argument list variations described in Matlab's BICGSTAB
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/blkdiag
opSpot/blkdiag
``` BLKDIAG   Block-diagonal concatenation of operator input arguments.

B = blkdiag(OP1,OP2,...) produces the block-diagonal operator

[ OP1                ]
B = [      OP2           ]
[           ...      ]
[                OPN ]```
M-File Help: opSpot/cgs
opSpot/cgs
``` CGS   Conjugate Gradients Squared Method.

X = cgs(A,B) attempts to solve the square linear system A*X=B via
the CGS method.

This routine is simply a wrapper to Matlab's own CGS routine,
and the argument list variations described in Matlab's CGS
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/char
opSpot/char
``` CHAR  Create a string representation of a Spot operator.

char(A) converts the Spot operator into a string representation.```
M-File Help: opSpot/conj
opSpot/conj
``` CONJ  Elementwise conjugate of operator.

conj(OP) is the elementwise conjugate of the Spot operator OP.```
M-File Help: opSpot/ctranspose
opSpot/ctranspose
``` '  Complex conjugate tranpose.
A' is the complex conjugate transpose of A.

ctranspose(A) is called for the syntax A' when A is an operator.```
M-File Help: opSpot/diag
opSpot/diag
``` DIAG  Diagonal operator and diagonals of an operator.

diag(OP) is the main diagonal of the Spot operator OP.```
M-File Help: opSpot/disp
opSpot/disp
``` DISP  Display a Spot operator.

disp(A) displays a Spot operator, excluding its name.

disp(A,NAME) displays a Spot operator along with its name.```
M-File Help: opSpot/display
opSpot/display
``` DISPLAY  Display an operator.

display(A) displays an operator.```
M-File Help: opSpot/double
opSpot/double
``` double  Converts a Spot operator to matrix.

double(A) converts a Spot operator to an explicit matrix.```
M-File Help: opSpot/drandn
opSpot/drandn
``` DRANDN  Normally distributed pseudorandom vector in the operator domain.

drandn(A) returns a pseudorandom vector in the domain of A.```
M-File Help: opSpot/eigs
opSpot/eigs
``` EIGS   Find a few eigenvalues and eigenvectors of an operator using ARPACK.

eigs(A) returns six of the largest eigenvalues of an operator.

This routine is simply a wrapper to Matlab's own EIGS routine, and
most of the argument-list variations described in Matlab's EIGS
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator, and only the largest eigenvalues are considered.

Supported usage includes

D = EIGS(A)
[V,D] = EIGS(A)
[V,D,FLAG] = EIGS(A)
[V,D,FLAG] = EIGS(A,K)
[V,D,FLAG] = EIGS(A,K,SIGMA)
[V,D,FLAG] = EIGS(A,K,SIGMA,OPTS)

Again, see Matlab's built-in EIGS for details on these calls.```
M-File Help: opSpot/end
opSpot/end
``` END   returns maximum index

end(OP,K,IDXCOUNT) returns the maximum index of operator
OP in dimension K. When IDXCOUNT equals one argument K is
ignored and the product of number of rows and columns of OP is
returned.```
M-File Help: opSpot/full
opSpot/full
``` FULL  Convert a Spot operator into a (dense) matrix.

X = full(A) converts the Spot operator A into a dense matrix X.```
M-File Help: opSpot/gmres
opSpot/gmres
``` GMRES   Generalized Minimum Residual Method.

X = gmres(A,B) attempts to solve the square linear system A*X=B via
the GMRES method.

This routine is simply a wrapper to Matlab's own GMRES routine,
and the argument list variations described in Matlab's GMRES
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/horzcat
opSpot/horzcat
``` HORZCAT  Horizontal concatenation.

[A B] is the horizonal concatenation of operators A and B.```
M-File Help: opSpot/imag
opSpot/imag
``` IMAG  Complex imaginary part.

imag(A) returns a new operator comprised of imaginary part of A.```
M-File Help: opSpot/inv
opSpot/inv
``` INV   Inverse of a linear operator.

inv(A) returns the operator inverse of A. This routine is
a simple front-end to opInverse.```
M-File Help: opSpot/isempty
opSpot/isempty
``` ISEMPTY  True for empty operator.

isempty(A) returns true if A is an empty operator.```
M-File Help: opSpot/isreal
opSpot/isreal
``` ISREAL  True for real operator.

isreal(A) returns true if A is a real operator.```
M-File Help: opSpot/isscalar
opSpot/isscalar
``` ISSCALAR  True if operator is a scalar.

isscalar(A) returns true if A is a 1-by-1 operator.```
M-File Help: opSpot/kron
opSpot/kron
``` KRON   Kronecker tensor product of operators.

kron(A,B) is the Kroneker tensor product of A and B.

kron(A,B,C,...) is the Kroneker product of A,B,C,...```
M-File Help: opSpot/length
opSpot/length
``` LENGTH  Maximum dimension of operator.

length(A) returns the maximum dimension of the operator A.```
M-File Help: opSpot/lsqr
opSpot/lsqr
``` LSQR   LSQR Method.

X = lsqr(A,B) attempts to solve the least-squares problem

minimize  || A*X - B ||_2

This routine is simply a wrapper to Matlab's own LSQR routine,
and the argument list variations described in Matlab's LSQR
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/minres
opSpot/minres
``` MINRES   Minimum Residual Method.

X = minres(A,B) attempts to find a minimum-norm residual solution
X to the symmetric linear system A*X=B via the MINRES method.

This routine is simply a wrapper to Matlab's own MINRES routine,
and the argument list variations described in Matlab's MINRES
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/minus
opSpot/minus
` -   Difference of two operators.`
M-File Help: opSpot/mldivide
opSpot/mldivide
``` \  Backslash or left matrix divide.

X = A\B is similar to Matlab's backslash operator. If A is a Spot
operator and B is a vector, then in general X is computed as the solution to the
least-squares problem

(*)  minimize  ||Ax - b||_2.

However, some Spot operators implement their own mldivide routines
that determine exactly how a solution to (*) is obtained.  For
example, the orthogonal operators (e.g., opWavlet) obtain X via
A'*b.

If A is a scalar and B is a spot operator, then X = opFoG(1/A,B).

The least-squares problem (*) is solved using LSQR with default
parameters specified by spotparams.```
M-File Help: opSpot/mpower
opSpot/mpower
``` ^   Matrix power.

A^y is A to the y power.```
M-File Help: opSpot/mrdivide
opSpot/mrdivide
``` /  Slash or right matrix divide.

X = A/B is similar to Matlab's slash operator. If B is a Spot
operator and A is a matrix then X is computed as the transpose
of the solution to the least-squares problem

(*)  minimize  ||B'x - A'||_F;

when A is a vector, this is a standard least-squares problem.

If B is a scalar and A is a spot operator, then X = opFoG(1/B,A).

The least-squares problem (*) is solved using LSQR with default
parameters specified by spotparams.```
M-File Help: opSpot/mtimes
opSpot/mtimes
``` *   Product of two operators.

A*B  returns an operator that is the product of two operators.```
M-File Help: opSpot/ndims
opSpot/ndims
``` NDIMS  Number of dimensions.

ndims(OP) always returns 2, i.e., all Spot operators are
representable as matrices.```
M-File Help: opSpot/normest
opSpot/normest
``` NORMEST Estimate the matrix 2-norm.

normest(S) is an estimate of the 2-norm of the matrix S.

normest(S,tol) uses relative error tol instead of 1e-6.

[nrm,cnt] = normest(..) also gives the number of iterations used.

This function is a minor adaptation of Matlab's built-in NORMEST.```
M-File Help: opSpot/pcg
opSpot/pcg
``` PCG   Preconditioned Conjugate Gradients Method.

X = pcg(A,B) attempts to solve the symmetric positive-definite
linear system A*X=B via the PCG method.

This routine is simply a wrapper to Matlab's own PCG routine,
and the argument list variations described in Matlab's PCG
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/pinv
opSpot/pinv
``` PINV   Pseudo-inverse of an operator

pinv(A) returns the operator pseudo-inverse of A.```
M-File Help: opSpot/plus
opSpot/plus
` +   Sum of two operators.`
M-File Help: opSpot/qmr
opSpot/qmr
``` QMR   Quasi-Minimal Residual Method.

X = qmr(A,B) attempts to solve the square linear system A*X=B via
the QMR method.

This routine is simply a wrapper to Matlab's own QMR routine,
and the argument list variations described in Matlab's QMR
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/real
opSpot/real
``` REAL  Complex real part.

opReal(A) returns an operator comprised of the real part of A.```
M-File Help: opSpot/rrandn
opSpot/rrandn
``` RRANDN  Normally distributed pseudorandom vector in the operator range.

rrandn(A) returns a pseudorandom vector in the range of A.```
M-File Help: opSpot/size
opSpot/size
``` size  Dimensions of a Spot operator.

D = size(A), for an M-by-N Spot operator A, returns the
two-element row vectors D = [M,N].

[M,N] = size(A) returns M and N as separate arguments.

M = size(A,DIM) retuns the length of the dimension specified by
the scalar DIM.  Note that DIM must be 1 or 2.```
M-File Help: opSpot/subsasgn
opSpot/subsasgn
` SUBSASGN   Subscribed assignment.`
M-File Help: opSpot/subsref
opSpot/subsref
` SUBSREF   Subscripted reference.`
M-File Help: opSpot/sum
opSpot/sum
``` SUM Sums rows or columns of a Spot operator.

S = sum(A), for an M-by-N Spot operator A, S is a row vector with the
sum of elements of each column.

S = SUM(A,DIM) sums along the dimension DIM.
Note that DIM must be 1 or 2.```
M-File Help: opSpot/symmlq
opSpot/symmlq
``` SYMMLQ   Symetric LQ Method.

X = symmlq(A,B) attempts to solve the system of linear equations A*X=B
for X, where A is symmetric.

This routine is simply a wrapper to Matlab's own MINRES routine,
and the argument list variations described in Matlab's MINRES
documentation are also allowed here.  The usage is identical to
Matlab's default version, except that the first argument must be a
Spot operator.```
M-File Help: opSpot/transpose
opSpot/transpose
``` .'   Operator tranpose.
A.' is the (non-conjugate) transpose of A.

transpose(A) is called for the syntax A.' when A is an operator.```
M-File Help: opSpot/uminus
opSpot/uminus
``` -   Unary minus.

-A  negates the operator A.```
M-File Help: opSpot/uplus
opSpot/uplus
``` +   Unary plus.

B = uplus(A), or B = +A, simply returns the operator A.```
M-File Help: opSpot/vertcat
opSpot/vertcat
``` VERTCAT  Vertical concatenation.

[A; B] is the vertical concatenation of the operators A and B.```