At some point you might want to create a new Spot operator class to suit your own problems. In this tutorial, we will go through the definition of the opZeros class, explaining how you would define your own class along the way.
Contents
First Lines
The first line in the file should specify the class name and say that it is a subclass of opSpot or another class such as opOrthogonal:
classdef opZeros < opSpot
You should then provide help comments about what the operator does:
%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.
Properties
Next define any class properties that the operator has in addition to the ones inherited by opSpot and its other superclasses. opZeros has no extra properties defined. opSpot has the following properties, which are common to all Spot operator classes:
properties( SetAccess = protected )
linear = 1; % Flag the op. as linear (1) or nonlinear (0)
counter
m = 0; % No. of rows
n = 0; % No. of columns
type = '';
cflag = false; % Complexity of underlying operator
children = {}; % Constituent operators (for a meta operator)
precedence = 1;
sweepflag = false; % whether we can do a sweep multiply, A*B
end
properties( Dependent = true, SetAccess = private )
nprods
end
All Spot operators store their size, whether they are complex or not, and several other properties. As seen above, you can also set the access to properties. Some Spot operator classes have certain properties that are public, and certain properties that have public "GetAccess" but private "SetAccess". The default access is public.
Methods
The first method that an operator needs is a constructor. The constructor for opZeros is below. It determines the values of m, n, and type according to the number and type of arguments passed in and then calls the opSpot constructor. More complicated operators such as opExtend have additional properties, and set these after calling the superclass constructor.
methods function op = opZeros(varargin) if nargin == 0 m = 1; n = 1; elseif nargin == 1 if length(varargin{1}) == 2 m = varargin{1}(1); n = varargin{1}(2); else m = varargin{1}; n = m; end elseif nargin == 2 m = varargin{1}; n = varargin{2}; else error('Too many input arguments.'); end op = op@opSpot('Zeros',m,n); op.sweepflag = true; end % function opZeros
Although the double function is defined in the @opSpot folder, opZeros has a more efficient implementation, as it only needs to create a matrix of zeros with the right dimensions. double is defined as a method in opZeros, overloading the generic double method:
function A = double(op) A = zeros(size(op)); end
end % methods - public
Spot operators can overload other functions as needed. The constructor and double are both public methods - they can be called on an opZero operator by the user. The next section in the class definition is the protected methods. As a subclass of opSpot, the only method other than the constructor that this class is required to implement is multiply(op,x,mode).
Spot operators are multiplied using the mtimes (or *) function. mtimes handles multiplication by scalars, calls opFoG if two Spot operators are being multiplied, and calls applyMultiply in the opSpot class if an operator and a matrix are being multiplied. The applyMultiply function checks the operator's sweepflag property. If sweepflag is set to true, the whole matrix is passed to the subclass's multiply function for a "sweep multiply". If sweepflag is false, applyMultiply calls the subclass operator's multiply function on each column of the matrix. For more information on multiplication with operators, see Using the Methods. Each operator's multiply function should take the "mode" into consideration. Mode 1 multiplies the operator, and mode 2 multiplies the operator's inverse.:
methods( Access = protected )
function y = multiply(op,x,mode)
if (mode == 1)
s = op.m;
else
s = op.n;
end
if any(isinf(x) | isnan(x))
y = ones(s,1) * NaN;
else
y = zeros(s,1);
end
end % function multiply
end % methods - protected
opZeros has sweepflag set to true, so the whole matrix is passed to the multiply method. Since multiplying any matrix by a matrix of zeros produces a column of zeros, this implementation is more efficient than the column-by-column approach.
end % classdef
This is the end of the opZeros definition. Most of the Spot operators are more complicated, with additional properties, complicated constructors, their own public methods, and more overloaded public methods. The random operators like opGuassian have implicit and explicit modes, which can create an explicit matrix or generate columns of a matrix as needed with a particular random number generator seed. opDCT and opDCT2 have a public method called spy, which produces a graphic representation of the operator. Look through the Spot classes for more examples of operator implementations.