Commit [9c905d] Maximize Restore History

start of the operators framework: moved existing operators into operators/ and deprecated the Gabor multiplier functions

Peter L. Søndergaard Peter L. Søndergaard 2013-04-22

1 2 > >> (Page 1 of 2)
removed gabor/gabmuleigs.m
removed gabor/spreadadj.m
removed gabor/spreadfun.m
removed gabor/spreadinv.m
removed gabor/spreadop.m
changed deprecated/gabgrouplasso.m
changed frames/Contents.m
changed gabor/Contents.m
copied frames/framemul.m -> operators/framemul.m
copied frames/framemuladj.m -> operators/framemuladj.m
copied frames/framemulappr.m -> operators/framemulappr.m
copied frames/framemuleigs.m -> operators/framemuleigs.m
copied frames/iframemul.m -> deprecated/gabmul.m
copied gabor/gabmul.m -> operators/gabmulappr.m
copied gabor/gabmulappr.m -> deprecated/gabmuleigs.m
copied gabor/spreadeigs.m -> operators/Contents.m
gabor/gabmuleigs.m
File was removed.
gabor/spreadadj.m
File was removed.
gabor/spreadfun.m
File was removed.
gabor/spreadinv.m
File was removed.
gabor/spreadop.m
File was removed.
deprecated/gabgrouplasso.m Diff Switch to side-by-side view
Loading...
frames/Contents.m Diff Switch to side-by-side view
Loading...
gabor/Contents.m Diff Switch to side-by-side view
Loading...
frames/iframemul.m to deprecated/gabmul.m
--- a/frames/iframemul.m
+++ b/deprecated/gabmul.m
@@ -1,75 +1,95 @@
-function [h,relres,iter]=iframemul(f,Fa,Fs,s,varargin)
-%IFRAMEMUL  Inverse of frame multiplier
-%   Usage: h=iframemul(f,Fa,Fs,s);
-%         [h,relres,iter]=iframemul(...);
+function h=gabmul(f,c,p3,p4,p5)
+%GABMUL  Apply Gabor multiplier
+%   Usage:  h=gabmul(f,c,a);
+%           h=gabmul(f,c,g,a);
+%           h=gabmul(f,c,ga,gs,a);
 %
 %   Input parameters:
-%          Fa   : Analysis frame
-%          Fs   : Synthesis frame
-%          s    : Symbol
-%          f    : Input signal
+%         f     : Input signal
+%         c     : symbol of Gabor multiplier
+%         g     : analysis/synthesis window
+%         ga    : analysis window
+%         gs    : synthesis window
+%         a     : Length of time shift.
+%   Output parameters:
+%         h     : Output signal
 %
-%   Output parameters: 
-%          h    : Output signal
+%   `gabmul` has been deprecated. Please use construct a frame multiplier
+%   and use |framemul| instead.
 %
-%   `iframemul(f,F,s)` applies the inverse of the frame multiplier with
-%   symbol *s* to the signal *f*. The frame *Fa* is used for analysis
-%   and the frame *Fs* for synthesis.
+%   A call to `gabmul(f,c,ga,gs,a)` can be replaced by ::
 %
-%   Because the inverse of a frame multiplier is not necessarily again a
-%   frame multiplier for the same frames, the problem is solved using an 
-%   iterative algorithm.
+%     [Fa,Fs]=framepair('dgt',ga,gs,a,M);
+%     fout=framemul(f,Fa,Fs,s);
 %
-%   `[h,relres,iter]=iframemul(...)` additionally returns the relative
-%   residuals in a vector *relres* and the number of iteration steps *iter*.
+%   Original help:
+%   --------------
 %
-%   `iframemul` takes the following parameters at the end of the line of
-%   input arguments:
+%   `gabmul(f,c,g,a)` filters *f* by a Gabor multiplier determined by
+%   the symbol *c* over the rectangular time-frequency lattice determined by
+%   *a* and *M*, where *M* is deduced from the size of *c*. The rows of *c*
+%   correspond to frequency, the columns to temporal sampling points.  The
+%   window *g* will be used for both analysis and synthesis.
 %
-%     'tol',t      Stop if relative residual error is less than the
-%                  specified tolerance. Default is 1e-9 
+%   `gabmul(f,c,a)` does the same using an optimally concentrated, tight
+%   Gaussian as window function.
 %
-%     'maxit',n    Do at most n iterations.
+%   `gabmul(f,c,ga,gs,a)` does the same using the window *ga* for analysis
+%   and *gs* for synthesis.
 %
-%     'print'      Display the progress.
+%   The adjoint operator of `gabmul(f,c,ga,gs,a)` is given by
+%   `gabmul(f,conj(c),gs,ga,a)`.
 %
-%     'quiet'      Don't print anything, this is the default.
+%   See also: dgt, idgt, gabdual, gabtight
+%
+%   Demos: demo_gabmul
 
-%   See also: iframemul
-  
-% Author: Peter L. S��ndergaard
+warning(['LTFAT: GABMUL has been deprecated, please use FRAMEMUL ' ...
+         'instead. See the help on GABMUL for more details.']);   
 
-if nargin < 4
-    error('%s: Too few input parameters.',upper(mfilename));
+error(nargchk(3,5,nargin));
+
+M=size(c,1);
+N=size(c,2);
+
+if nargin==3
+  a=p3;
+  L=a*N;
+  ga=gabtight(a,M,L);
+  gs=ga;
 end;
 
-definput.keyvals.tol=1e-9;
-definput.keyvals.maxit=100;
-definput.keyvals.printstep=10;
-definput.flags.print={'quiet','print'};
+if nargin==4;
+  ga=p3;
+  gs=p3;
+  a=p4;
+ end;
 
-[flags,kv]=ltfatarghelper({},definput,varargin);
-
-% Check for compatibility
-L1=framelength(Fa,size(f,1));
-L2=framelengthcoef(Fs,size(s,1));
-if L1~=L2
-    error(['%s: The symbol and signal lengths are incompatible.'],upper(mfilename));
+if nargin==5;  
+  ga=p3;
+  gs=p4;
+  a=p5;
 end;
 
-% This is not *strictly* necessary, but we cannot check that the symbol
-% is complex-valued in just the right way.
-if Fa.realinput && ~isreal(s)
-    error(['%s: For real-valued-input-only frames, the symbol must also ' ...
-           'be real.'],upper(mfilename));
+if numel(c)==1
+  error('Size of symbol is too small. You probably forgot to supply it.');
 end;
 
-% The frame multiplier is not positive definite, so we cannot solve it
-% directly using pcg.
-% Apply the multiplier followed by its adjoint. 
-A=@(x) framemuladj(framemul(x,Fa,Fs,s),Fa,Fs,s);
 
-[h,flag,dummytilde,iter1,relres]=pcg(A,framemuladj(f,Fa,Fs,s),kv.tol,kv.maxit);
+assert_squarelat(a,M,'GABMUL',0);
+
+% Change f to correct shape.
+[f,Ls,W,wasrow,remembershape]=comp_sigreshape_pre(f,'DGT',0);
+
+[coef,Ls]=dgt(f,ga,a,M);
+
+for ii=1:W
+  coef(:,:,ii)=coef(:,:,ii).*c;
+end;
 
 
+h=idgt(coef,gs,a,Ls);
 
+% Change h to have same shape as f originally had.
+h=comp_sigreshape_post(h,Ls,wasrow,remembershape);
+
gabor/gabmul.m to operators/gabmulappr.m
--- a/gabor/gabmul.m
+++ b/operators/gabmulappr.m
@@ -1,82 +1,123 @@
-function h=gabmul(f,c,p3,p4,p5)
-%GABMUL  Apply Gabor multiplier
-%   Usage:  h=gabmul(f,c,a);
-%           h=gabmul(f,c,g,a);
-%           h=gabmul(f,c,ga,gs,a);
+function [sym,lowb,upb]=gabmulappr(T,p2,p3,p4,p5);
+%GABMULAPPR  Best Approximation by a Gabor multiplier
+%   Usage:  sym=gabmulappr(T,a,M);
+%           sym=gabmulappr(T,g,a,M);
+%           sym=gabmulappr(T,ga,gs,a,M);
+%           [sym,lowb,upb]=gabmulappr( ... );
 %
 %   Input parameters:
-%         f     : Input signal
-%         c     : symbol of Gabor multiplier
+%         T     : matrix to be approximated
 %         g     : analysis/synthesis window
 %         ga    : analysis window
 %         gs    : synthesis window
 %         a     : Length of time shift.
+%         M     : Number of channels.
+%
 %   Output parameters:
-%         h     : Output signal
+%         sym   : symbol
 %
-%   `gabmul(f,c,g,a)` filters *f* by a Gabor multiplier determined by
-%   the symbol *c* over the rectangular time-frequency lattice determined by
-%   *a* and *M*, where *M* is deduced from the size of *c*. The rows of *c*
-%   correspond to frequency, the columns to temporal sampling points.  The
-%   window *g* will be used for both analysis and synthesis.
+%   `sym=gabmulappr(T,g,a,M)` calculates the best approximation of the given
+%   matrix *T* in the Frobenius norm by a Gabor multiplier determined by the
+%   symbol *sym* over the rectangular time-frequency lattice determined by
+%   *a* and *M*.  The window *g* will be used for both analysis and
+%   synthesis.
 %
-%   `gabmul(f,c,a)` does the same using an optimally concentrated, tight
+%   `gabmulappr(T,a,M)` does the same using an optimally concentrated, tight
 %   Gaussian as window function.
 %
-%   `gabmul(f,c,ga,gs,a)` does the same using the window *ga* for analysis
+%   `gabmulappr(T,gs,ga,a)` does the same using the window *ga* for analysis
 %   and *gs* for synthesis.
 %
-%   The adjoint operator of `gabmul(f,c,ga,gs,a)` is given by
-%   `gabmul(f,conj(c),gs,ga,a)`.
+%   `[sym,lowb,upb]=gabmulappr(...)` additionally returns the lower and
+%   upper Riesz bounds of the rank one operators, the projections resulting
+%   from the tensor products of the analysis and synthesis frames.
 %
-%   See also: dgt, idgt, gabdual, gabtight
+%   See also: gabmul
 %
-%   Demos: demo_gabmul
+%   Demos: demo_gabmulappr
+%
+%   References: doetor09 ba07 ba06 fehakr04
 
-
+% AUTHOR    : Monika D��erfler
+% REFERENCE : REF_GABMULAPPR
+% TESTING   : TEST_GABMULAPPR
+  
 error(nargchk(3,5,nargin));
 
-M=size(c,1);
-N=size(c,2);
+L=size(T,1);
+
+if size(T,2)~=L
+  error('T must be square.');
+end;
 
 if nargin==3
-  a=p3;
-  L=a*N;
+  % Usage: sym=gabmulappr(T,a,M);
+  a=p2;
+  M=p3;
   ga=gabtight(a,M,L);
   gs=ga;
 end;
 
-if nargin==4;
-  ga=p3;
+if nargin==4
+  % Usage: sym=gabmulappr(T,g,a,M);
+  ga=p2;
+  gs=p2;
+  a=p3;
+  M=p4;
+end;
+  
+if nargin==5
+  % Usage: sym=gabmulappr(T,ga,gm,a,M);
+  ga=p2;
   gs=p3;
   a=p4;
- end;
-
-if nargin==5;  
-  ga=p3;
-  gs=p4;
-  a=p5;
+  M=p5;
 end;
 
-if numel(c)==1
-  error('Size of symbol is too small. You probably forgot to supply it.');
+if size(ga,2)>1
+  if size(ga,1)>1
+    error('Input g/ga must be a vector');
+  else
+    % ga was a row vector.
+    ga=ga(:);
+  end;
 end;
 
-
-assert_squarelat(a,M,'GABMUL',0);
-
-% Change f to correct shape.
-[f,Ls,W,wasrow,remembershape]=comp_sigreshape_pre(f,'DGT',0);
-
-[coef,Ls]=dgt(f,ga,a,M);
-
-for ii=1:W
-  coef(:,:,ii)=coef(:,:,ii).*c;
+if size(gs,2)>1
+  if size(gs,1)>1
+    error('Input g/gs must be a vector');
+  else
+    % gs was a row vector.
+    gs=gs(:);
+  end;
 end;
 
+N=L/a;
+b=L/M;
 
-h=idgt(coef,gs,a,Ls);
+Vg=dgt(gs,ga,1,L);
 
-% Change h to have same shape as f originally had.
-h=comp_sigreshape_post(h,Ls,wasrow,remembershape);
+s=spreadfun(T);
 
+A=zeros(N,M);
+V=zeros(N,M);
+for k=0:b-1 
+  for l=0:a-1
+    A = A+ s(l*N+1:(l+1)*N,k*M+1:k*M+M).*conj(Vg(l*N+1:(l+1)*N,k*M+1:k*M+M));
+    V = V+abs(Vg(l*N+1:(l+1)*N,k*M+1:k*M+M)).^2;
+  end;
+end;
+
+if nargout>1
+  lowb = min(V(:));
+  upb  = max(V(:));
+end;
+
+SF1=A./V;
+
+SF=zeros(N,M);
+jjmod=mod(-M:-1,M)+1;
+iimod=mod(-N:-1,N)+1;
+SF=SF1(iimod,jjmod);
+
+sym=b*dsft(SF)*sqrt(M)/sqrt(N);
gabor/gabmulappr.m to deprecated/gabmuleigs.m
--- a/gabor/gabmulappr.m
+++ b/deprecated/gabmuleigs.m
@@ -1,123 +1,196 @@
-function [sym,lowb,upb]=gabmulappr(T,p2,p3,p4,p5);
-%GABMULAPPR  Best Approximation by a Gabor multiplier
-%   Usage:  sym=gabmulappr(T,a,M);
-%           sym=gabmulappr(T,g,a,M);
-%           sym=gabmulappr(T,ga,gs,a,M);
-%           [sym,lowb,upb]=gabmulappr( ... );
+function [V,D]=gabmuleigs(K,c,p3,varargin)
+%GABMULEIGS  Eigenpairs of Gabor multiplier
+%   Usage:  h=gabmuleigs(K,c,g,a);
+%           h=gabmuleigs(K,c,a);
+%           h=gabmuleigs(K,c,ga,gs,a);
 %
 %   Input parameters:
-%         T     : matrix to be approximated
+%         K     : Number of eigenvectors to compute.
+%         c     : symbol of Gabor multiplier
 %         g     : analysis/synthesis window
 %         ga    : analysis window
 %         gs    : synthesis window
 %         a     : Length of time shift.
-%         M     : Number of channels.
+%   Output parameters:
+%         V     : Matrix containing eigenvectors.
+%         D     : Eigenvalues.
 %
-%   Output parameters:
-%         sym   : symbol
+%   `gabmuleigs` has been deprecated. Please use construct a frame multiplier
+%   and use |framemuleigs| instead.
 %
-%   `sym=gabmulappr(T,g,a,M)` calculates the best approximation of the given
-%   matrix *T* in the Frobenius norm by a Gabor multiplier determined by the
-%   symbol *sym* over the rectangular time-frequency lattice determined by
-%   *a* and *M*.  The window *g* will be used for both analysis and
-%   synthesis.
+%   A call to `gabmuleigs(K,c,ga,gs,a)` can be replaced by ::
 %
-%   `gabmulappr(T,a,M)` does the same using an optimally concentrated, tight
-%   Gaussian as window function.
+%     [Fa,Fs]=framepair('dgt',ga,gs,a,M);
+%     [V,D]=framemuleigs(Fa,Fs,s,K);
 %
-%   `gabmulappr(T,gs,ga,a)` does the same using the window *ga* for analysis
-%   and *gs* for synthesis.
+%   Original help:
+%   --------------
 %
-%   `[sym,lowb,upb]=gabmulappr(...)` additionally returns the lower and
-%   upper Riesz bounds of the rank one operators, the projections resulting
-%   from the tensor products of the analysis and synthesis frames.
+%   `gabmuleigs(K,c,g,a)` computes the *K* largest eigenvalues and eigen-
+%   vectors of the Gabor multiplier with symbol *c* and time shift *a*.  The
+%   number of channels is deduced from the size of the symbol *c*.  The
+%   window *g* will be used for both analysis and synthesis.
 %
-%   See also: gabmul
+%   `gabmuleigs(K,c,ga,gs,a)` does the same using the window the window *ga*
+%   for analysis and *gs* for synthesis.
 %
-%   Demos: demo_gabmulappr
+%   `gabmuleigs(K,c,a)` does the same using the a tight Gaussian window of
+%   for analysis and synthesis.
 %
-%   References: doetor09 ba07 ba06 fehakr04
+%   If *K* is empty, then all eigenvalues/pairs will be returned.
+%
+%   `gabmuleigs` takes the following parameters at the end of the line of input
+%   arguments:
+%
+%     'tol',t      Stop if relative residual error is less than the
+%                  specified tolerance. Default is 1e-9 
+%
+%     'maxit',n    Do at most n iterations.
+%
+%     'iter'       Call `eigs` to use an iterative algorithm.
+%
+%     'full'       Call `eig` to sole the full problem.
+%
+%     'auto'       Use the full method for small problems and the
+%                  iterative method for larger problems. This is the
+%                  default. 
+%
+%     'crossover',c
+%                  Set the problem size for which the 'auto' method
+%                  switches. Default is 200.
+%
+%     'print'      Display the progress.
+%
+%     'quiet'      Don't print anything, this is the default.
+%
+%   See also: gabmul, dgt, idgt, gabdual, gabtight
 
-% AUTHOR    : Monika D��erfler
-% REFERENCE : REF_GABMULAPPR
-% TESTING   : TEST_GABMULAPPR
-  
-error(nargchk(3,5,nargin));
+% Change this to 1 or 2 to see the iterative method in action.
+printopts=0;
 
-L=size(T,1);
-
-if size(T,2)~=L
-  error('T must be square.');
+if nargin<3
+  error('%s: Too few input parameters.',upper(mfilename));
 end;
 
-if nargin==3
-  % Usage: sym=gabmulappr(T,a,M);
-  a=p2;
-  M=p3;
+if nargout==2
+  doV=1;
+else
+  doV=0;
+end;
+
+M=size(c,1);
+N=size(c,2);
+
+istight=1;
+if numel(p3)==1
+  % Usage: h=gabmuleigs(c,K,a);  
+  a=p3;
+  L=N*a;
   ga=gabtight(a,M,L);
   gs=ga;
-end;
-
-if nargin==4
-  % Usage: sym=gabmulappr(T,g,a,M);
-  ga=p2;
-  gs=p2;
-  a=p3;
-  M=p4;
-end;
-  
-if nargin==5
-  % Usage: sym=gabmulappr(T,ga,gm,a,M);
-  ga=p2;
-  gs=p3;
-  a=p4;
-  M=p5;
-end;
-
-if size(ga,2)>1
-  if size(ga,1)>1
-    error('Input g/ga must be a vector');
-  else
-    % ga was a row vector.
-    ga=ga(:);
+  arglist=varargin;
+else 
+  if numel(varargin{1})==1
+    % Usage: h=gabmuleigs(c,K,g,a);  
+    ga=p3;
+    gs=p3;
+    a=varargin{1};
+    L=N*a;
+    arglist=varargin(2:end);
+  else 
+    if numel(varargin{2})==1
+      % Usage: h=gabmuleigs(c,K,ga,gs,a);  
+      ga=p3;
+      gs=varargin{1};
+      a =varargin{2};
+      L=N*a;
+      istight=0;
+      arglist=varargin(3:end);
+    end;    
   end;
 end;
 
-if size(gs,2)>1
-  if size(gs,1)>1
-    error('Input g/gs must be a vector');
+definput.keyvals.maxit=100;
+definput.keyvals.tol=1e-9;
+definput.keyvals.crossover=200;
+definput.flags.print={'quiet','print'};
+definput.flags.method={'auto','iter','full'};
+
+
+[flags,kv]=ltfatarghelper({},definput,arglist);
+
+
+% Do the computation. For small problems a direct calculation is just as
+% fast.
+
+if (flags.do_iter) || (flags.do_auto && L>kv.crossover)
+  
+  if flags.do_print
+    opts.disp=1;
   else
-    % gs was a row vector.
-    gs=gs(:);
+    opts.disp=0;
   end;
+  opts.isreal = false;
+  opts.maxit  = kv.maxit;
+  opts.tol    = kv.tol;
+  
+  % Setup afun
+  afun(1,c,ga,gs,a,M,L)
+  
+  if doV
+    [V,D] = eigs(@afun,L,K,'LM',opts);
+  else
+    D     = eigs(@afun,L,K,'LM',opts);
+  end;
+
+else
+  % Compute the transform matrix.
+  bigM=tfmat('gabmul',c,ga,gs,a);
+
+  if doV
+    [V,D]=eig(bigM);
+  else
+    D=eig(bigM);
+  end;
+
+
 end;
 
-N=L/a;
-b=L/M;
+% The output from eig and eigs is a diagonal matrix, so we must extract the
+% diagonal.
+D=diag(D);
 
-Vg=dgt(gs,ga,1,L);
+% Sort them in descending order
+[~,idx]=sort(abs(D),1,'descend');
+D=D(idx(1:K));
 
-s=spreadfun(T);
-
-A=zeros(N,M);
-V=zeros(N,M);
-for k=0:b-1 
-  for l=0:a-1
-    A = A+ s(l*N+1:(l+1)*N,k*M+1:k*M+M).*conj(Vg(l*N+1:(l+1)*N,k*M+1:k*M+M));
-    V = V+abs(Vg(l*N+1:(l+1)*N,k*M+1:k*M+M)).^2;
-  end;
+if doV
+  V=V(:,idx(1:K));
 end;
 
-if nargout>1
-  lowb = min(V(:));
-  upb  = max(V(:));
-end;
+% Clean the eigenvalues, if we know that they are real-valued
+%if isreal(ga) && isreal(gs) && isreal(c)
+%  D=real(D);
+%end;
 
-SF1=A./V;
-
-SF=zeros(N,M);
-jjmod=mod(-M:-1,M)+1;
-iimod=mod(-N:-1,N)+1;
-SF=SF1(iimod,jjmod);
-
-sym=b*dsft(SF)*sqrt(M)/sqrt(N);
+% The function has been written in this way, because Octave (at the time
+% of writing) does not accept additional parameters at the end of the
+% line of input arguments for eigs
+function y=afun(x,c_in,ga_in,gs_in,a_in,M_in,L_in)
+  persistent c;
+  persistent ga;
+  persistent gs;
+  persistent a;
+  persistent M;
+  persistent L; 
+  
+  if nargin>1
+    c  = c_in; 
+    ga = ga_in;
+    gs = gs_in;
+    a  = a_in; 
+    M  = M_in; 
+    L  = L_in;
+  else
+    y=comp_idgt(c.*comp_dgt(x,ga,a,M,[0 1],0,0,0),gs,a,[0 1],0,0);
+  end;
gabor/spreadeigs.m to operators/Contents.m
--- a/gabor/spreadeigs.m
+++ b/operators/Contents.m
@@ -1,39 +1,21 @@
-function [V,D]=spreadeigs(K,coef);
-%SPREADEIGS  Eigenpairs of Spreading operator
-%   Usage: h=spreadeigs(K,c);
+% LTFAT - Operators
 %
-%   `spreadeigs(K,c)` computes the *K* largest eigenvalues and eigen-
-%   vectors of the spreading operator with symbol *c*.
+%  Peter L. Søndergaard, 2013.
 %
-%   See also:  tconv, spreadfun, spreadinv, spreadadj
-
-error(nargchk(2,2,nargin));
-
-if ndims(coef)>2 || size(coef,1)~=size(coef,2)
-    error('Input symbol coef must be a square matrix.');
-end;
-
-L=size(coef,1);
-
-% This version explicitly constucts the matrix representation T
-% and then applies this matrix as the final step.
-coef=fft(coef);
-  
-T=zeros(L);
-for ii=0:L-1
-  for jj=0:L-1
-    T(ii+1,jj+1)=coef(ii+1,mod(ii-jj,L)+1);
-  end;
-end;
-
-if nargout==2
-  doV=1;
-else
-  doV=0;
-end;
-
-if doV
-  [V,D]=eig(T);
-else
-  D=eig(T);
-end;
+%  Frame multipliers
+%    FRAMEMUL          - Apply frame multiplier
+%    IFRAMEMUL         - Apply the inverse of a frame multipllier
+%    FRAMEMULADJ       - Apply the adjoint of a frame multiplier
+%    FRAMEMULAPPR      - Best approx. by frame multiplier
+%    FRAMEMULEIGS      - Eigenpairs of a frame multiplier
+%    GABMULAPPR        - Best approximation by a Gabor mult.
+%
+%  Spreading operators
+%    SPREADOP          - Spreading operator
+%    SPREADINV         - Apply inverse spreading operator
+%    SPREADADJ         - Symbol of adjoint spreading operator
+%    SPREADFUN         - Symbol of operator expressed as a matrix
+%    SPREADEIGS        - Eigenpairs of spreading operator
+%
+%  For help, bug reports, suggestions etc. please send email to
+%  ltfat-help@lists.sourceforge.net
1 2 > >> (Page 1 of 2)