# doc-cache created by Octave 9.2.0
# name: cache
# type: cell
# rows: 3
# columns: 19
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
Contents


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1286
 LTFAT - Operators

  Peter L. Soendergaard, 2013 - 2023.

  General operator framework
    OPERATORNEW       - Construct a new operator
    OPERATOR          - Apply an operator
    IOPERATOR         - Apply the inverse of an operator
    OPERATORADJ       - Apply the adjoint of an operator
    OPERATORAPPR      - Best approx. by operator
    OPERATOREIGS      - Eigenpairs of an operator
    OPERATORMATRIX    - Matrix representation of an operator

  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 visit 
  http://github.com/ltfat/ltfat/issues

   Url: http://ltfat.github.io/doc/operators/Contents.html



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
 LTFAT - Operators



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
framemul


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1415
 -- Function: framemul
     FRAMEMUL  Frame multiplier
        Usage:  h=framemul(f,Fa,Fs,s);
     
        Input parameters:
               Fa   : Analysis frame
               Fs   : Synthesis frame
               s    : Symbol
               f    : Input signal
     
        Output parameters: 
               h    : Output signal
     
        FRAMEMUL(f,Fa,Fs,s) applies the frame multiplier with symbol s*
        to the signal f. The frame Fa is used for analysis and the frame
        Fs for synthesis.
     
        Examples:
        ---------
     
        In the following example Gabor coefficients obtained through the DGT 
        of pink noise are multiplied by the symbol batmask before resynthesis. 
        The result of this operation is an output signal h that is constructed 
        through a Gabor expansion of the modified coefficients.:
     
           f = pinknoise(400);
           a = 10;
           M = 40;
           [Fa, Fs] = framepair('dgt', 'gauss', 'dual', a, M); 
           s = framenative2coef(Fa, batmask);
           fhat = framemul(f, Fa, Fs, s);
           figure(1);
           plotframe(Fa,frana(Fa,f),'clim',[-100,-20]);
           figure(2);
           plotframe(Fa,s,'lin');
           figure(3);
           plotframe(Fa,frana(Fa,fhat),'clim',[-100,-20]);
     
     *Url*: <http://ltfat.github.io/doc/operators/framemul.html>

     See also: iframemul, framemuladj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
FRAMEMUL  Frame multiplier
   Usage:  h=framemul(f,Fa,Fs,s);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
framemuladj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 738
 -- Function: framemuladj
     FRAMEMULADJ  Adjoint operator of frame multiplier
        Usage: h=framemuladj(f,Fa,Fs,s);
     
        Input parameters:
               Fa   : Analysis frame
               Fs   : Synthesis frame
               s    : Symbol
               f    : Input signal
     
        Output parameters: 
               h    : Output signal
     
        FRAMEMULADJ(f,Fa,Fs,s) applies the adjoint of the frame multiplier
        with symbol s to the signal f. The frame Fa is used for analysis
        and the frame Fs for synthesis. This is equivalent to calling
        framemul(f,Fs,Fa,conj(s)).
     
     
     *Url*: <http://ltfat.github.io/doc/operators/framemuladj.html>

     See also: framemul, iframemul.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEMULADJ  Adjoint operator of frame multiplier
   Usage: h=framemuladj(f,F...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
framemulappr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1059
 -- Function: framemulappr
     FRAMEMULAPPR  Best Approximation of a matrix by a frame multiplier
        Usage: s=framemulappr(Fa,Fs,T);
              [s,TA]=framemulappr(Fa,Fs,T);
     
        Input parameters:
               Fa   : Analysis frame
               Fs   : Synthesis frame
               T    : The operator represented as a matrix
     
        Output parameters: 
               s    : Symbol of best approximation
               TA   : The best approximation of the matrix T
     
        s=FRAMEMULAPPR(Fa,Fs,T) computes the symbol s of the frame
        multiplier that best approximates the matrix T in the Frobenious norm
        of the matrix (the Hilbert-Schmidt norm of the operator). The frame
        multiplier uses Fa for analysis and Fs for synthesis.
     
        Examples:
        
          T = eye(2,2);
          D = [0 1/sqrt(2) -1/sqrt(2); 1 -1/sqrt(2) -1/sqrt(2)];
          F = frame('gen',D);
          [coeff,TA] = framemulappr(F,F,T)
     
     
     *Url*: <http://ltfat.github.io/doc/operators/framemulappr.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEMULAPPR  Best Approximation of a matrix by a frame multiplier
   Usage: ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
framemuleigs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2424
 -- Function: framemuleigs
     FRAMEMULEIGS  Eigenpairs of frame multiplier
        Usage:  [V,D]=framemuleigs(Fa,Fs,s,K);
                D=framemuleigs(Fa,Fs,s,K,...);
     
        Input parameters:
              Fa    : Analysis frame
              Fs    : Synthesis frame
              s     : Symbol of Gabor multiplier
              K     : Number of eigenvectors to compute.
        Output parameters:
              V     : Matrix containing eigenvectors.
              D     : Eigenvalues.
     
        [V,D]=FRAMEMULEIGS(Fa,Fs,s,K) computes the K largest eigenvalues 
        and eigen-vectors of the frame multiplier with symbol s, analysis 
        frame Fa and synthesis frame Fs. The eigenvectors are stored as 
        column vectors in the matrix V and the corresponding eigenvalues in 
        the vector D.
     
        If K is empty, then all eigenvalues/pairs will be returned.
     
        D=FRAMEMULEIGS(...) computes only the eigenvalues.
     
        FRAMEMULEIGS 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 solve 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.
     
        Examples:
        ---------
     
        The following example calculates and plots the first eigenvector of the
        Gabor multiplier given by the BATMASK function. Note that the mask
        must be converted to a column vector to work with in this framework:
     
          mask=batmask;
          [Fa,Fs]=framepair('dgt','gauss','dual',10,40);
          [V,D]=framemuleigs(Fa,Fs,mask(:));
          sgram(V(:,1),'dynrange',90);
     
     *Url*: <http://ltfat.github.io/doc/operators/framemuleigs.html>

     See also: framemul, framemulappr.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEMULEIGS  Eigenpairs of frame multiplier
   Usage:  [V,D]=framemuleigs(Fa...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
gabmulappr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2414
 -- Function: gabmulappr
     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:
              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:
              sym   : symbol
     
        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.
     
        GABMULAPPR(T,a,M) does the same using an optimally concentrated, tight
        Gaussian as window function.
     
        GABMULAPPR(T,gs,ga,a) does the same using the window ga for analysis
        and gs for synthesis.
     
        [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.
     
     
     
        References:
          M. Doerfler and B. Torresani. Representation of operators in the
          time-frequency domain and generalized Gabor multipliers. J. Fourier
          Anal. Appl., 16(2):261--293, April 2010.
          
          P. Balazs. Hilbert-Schmidt operators and frames - classification, best
          approximation by multipliers and algorithms. International Journal of
          Wavelets, Multiresolution and Information Processing, 6:315 -- 330,
          2008.
          
          P. Balazs. Basic definition and properties of Bessel multipliers.
          Journal of Mathematical Analysis and Applications, 325(1):571--585,
          January 2007.
          
          H. G. Feichtinger, M. Hampejs, and G. Kracher. Approximation of
          matrices by Gabor multipliers. IEEE Signal Procesing Letters,
          11(11):883--886, 2004.
          
     *Url*: <http://ltfat.github.io/doc/operators/gabmulappr.html>

     See also: framemulappr, demo_gabmulappr.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
GABMULAPPR  Best Approximation by a Gabor multiplier
   Usage:  sym=gabmulapp...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
iframemul


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1415
 -- Function: iframemul
     IFRAMEMUL  Inverse of frame multiplier
        Usage: h=iframemul(f,Fa,Fs,s);
              [h,relres,iter]=iframemul(...);
     
        Input parameters:
               Fa   : Analysis frame
               Fs   : Synthesis frame
               s    : Symbol
               f    : Input signal
     
        Output parameters: 
               h    : Output signal
     
        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.
     
        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.
     
        [h,relres,iter]=IFRAMEMUL(...) additionally returns the relative
        residuals in a vector relres and the number of iteration steps iter.
     
        IFRAMEMUL 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.
     
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     *Url*: <http://ltfat.github.io/doc/operators/iframemul.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
IFRAMEMUL  Inverse of frame multiplier
   Usage: h=iframemul(f,Fa,Fs,s);
    ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
ioperator


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 594
 -- Function: ioperator
     IOPERATOR  Apply inverse of operator
        Usage: c=ioperator(Op,f);
     
        c=IOPERATOR(Op,f) applies the inverse op the operator Op to the
        input signal f.  The operator object Op must have been created using
        OPERATORNEW.
     
        If f is a matrix, the transform will be applied along the columns
        of f. If f is an N-D array, the transform will be applied along
        the first non-singleton dimension.
     
     *Url*: <http://ltfat.github.io/doc/operators/ioperator.html>

     See also: operatornew, operator, operatoradj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
IOPERATOR  Apply inverse of operator
   Usage: c=ioperator(Op,f);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
operator


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 555
 -- Function: operator
     OPERATOR  Apply operator
        Usage: c=operator(Op,f);
     
        c=OPERATOR(Op,f) applies the operator Op to the input signal f.
        The operator object Op must have been created using OPERATORNEW.
     
        If f is a matrix, the transform will be applied along the columns
        of f. If f is an N-D array, the transform will be applied along
        the first non-singleton dimension.
     
     *Url*: <http://ltfat.github.io/doc/operators/operator.html>

     See also: operatornew, ioperator, operatoradj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
OPERATOR  Apply operator
   Usage: c=operator(Op,f);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
operatoradj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 619
 -- Function: operatoradj
     OPERATORADJ  Apply the adjoint of an operator
        Usage: c=operatoradj(Op,f);
     
        c=OPERATORADJ(Op,f) applies the adjoint operator of the operator Op*
        to the input signal f.  The operator object Op must have been
        created using OPERATORNEW.
     
        If f is a matrix, the transform will be applied along the columns
        of f. If f is an N-D array, the transform will be applied along
        the first non-singleton dimension.
     
     *Url*: <http://ltfat.github.io/doc/operators/operatoradj.html>

     See also: operatornew, operator, ioperator.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
OPERATORADJ  Apply the adjoint of an operator
   Usage: c=operatoradj(Op,f);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
operatorappr


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 629
 -- Function: operatorappr
     OPERATORAPPR  Best approximation by operator
        Usage: c=operatorappr(Op,K);
     
        Opout=OPERATORAPPR(Opin,T) computes the an operator Opout of the
        same type as Opin that best approximates the matrix T in the
        Frobenious norm of the matrix (the Hilbert-Schmidt norm of the
        operator).
     
        For some operator classes, the approximation is always exact, so that
        operator(Opout,f) computes the exact same result as T'*f.
     
     *Url*: <http://ltfat.github.io/doc/operators/operatorappr.html>

     See also: operatornew, operator, operatoreigs.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
OPERATORAPPR  Best approximation by operator
   Usage: c=operatorappr(Op,K);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
operatoreigs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1487
 -- Function: operatoreigs
     OPERATOREIGS  Apply the adjoint of an operator
        Usage: c=operatoreigs(Op,K);
     
        [V,D]=OPERATOREIGS(Op,K) computes the K largest eigenvalues and
        eigenvectors of the operator Op to the input signal f.  The operator
        object Op must have been created using OPERATORNEW.
     
        If K is empty, then all eigenvalues/pairs will be returned.
     
        D=OPERATOREIGS(...) computes only the eigenvalues.
     
        OPERATOREIGS 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 solve 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.
     
     *Url*: <http://ltfat.github.io/doc/operators/operatoreigs.html>

     See also: operatornew, operator, ioperator.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
OPERATOREIGS  Apply the adjoint of an operator
   Usage: c=operatoreigs(Op,K);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
operatormatrix


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 425
 -- Function: operatormatrix
     OPERATORMATRIX  Matrix representation of an operator
        Usage: T=operatormatrix(Op);
     
        T=OPERATORMATRIX(Op) returns the matrix representation T of the
        operator Op. The operator object Op must have been created using
        OPERATORNEW.
     
     *Url*: <http://ltfat.github.io/doc/operators/operatormatrix.html>

     See also: operatornew, operator, operatoreigs.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
OPERATORMATRIX  Matrix representation of an operator
   Usage: T=operatormatr...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
operatornew


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 814
 -- Function: operatornew
     OPERATORNEW  Construct a new operator
        Usage: F=operatornew(otype,...);
     
        Op=OPERATORNEW(otype,...) constructs a new operator object Op of type
        otype. Arguments following otype are specific to the type of operator
        chosen.
     
        Frame multipliers
        -----------------
     
        OPERATORNEW('framemul',Fa,Fs,s) constructs a frame multiplier with
        analysis frame Fa, synthesis frame Fs and symbol s. See the help on
        FRAMEMUL.
     
        Spreading operators
        -------------------
     
        OPERATORNEW('spread',s) constructs a spreading operator with symbol
        s. See the help on SPREADOP.
       
     *Url*: <http://ltfat.github.io/doc/operators/operatornew.html>

     See also: operator, ioperator.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
OPERATORNEW  Construct a new operator
   Usage: F=operatornew(otype,...);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
spreadadj


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 389
 -- Function: spreadadj
     SPREADADJ  Symbol of adjoint spreading function
        Usage: cadj=spreadadj(c);
     
        cadj=SPREADADJ(c) computes the symbol cadj of the spreading
        operator that is the adjoint of the spreading operator with symbol c.
     
     *Url*: <http://ltfat.github.io/doc/operators/spreadadj.html>

     See also: spreadop, tconv, spreadfun, spreadinv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
SPREADADJ  Symbol of adjoint spreading function
   Usage: cadj=spreadadj(c);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
spreadeigs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 370
 -- Function: spreadeigs
     SPREADEIGS  Eigenpairs of Spreading operator
        Usage: h=spreadeigs(K,c);
     
        SPREADEIGS(K,c) computes the K largest eigenvalues and eigen-
        vectors of the spreading operator with symbol c.
     
     *Url*: <http://ltfat.github.io/doc/operators/spreadeigs.html>

     See also: tconv, spreadfun, spreadinv, spreadadj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
SPREADEIGS  Eigenpairs of Spreading operator
   Usage: h=spreadeigs(K,c);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
spreadfun


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 506
 -- Function: spreadfun
     SPREADFUN  Spreading function of a matrix
        Usage:  c=spreadfun(T);
     
        SPREADFUN(T) computes the spreading function of the operator T,
        represented as a matrix. The spreading function represent the operator T*
        as a weighted sum of time-frequency shifts. See the help text for
        SPREADOP for the exact definition.
     
     *Url*: <http://ltfat.github.io/doc/operators/spreadfun.html>

     See also: spreadop, tconv, spreadinv, spreadadj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
SPREADFUN  Spreading function of a matrix
   Usage:  c=spreadfun(T);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
spreadinv


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 464
 -- Function: spreadinv
     SPREADINV  Apply inverse spreading operator
        Usage: h=spreadinv(f,c);
     
        SPREADINV(c) computes the symbol of the inverse of the spreading
        operator with symbol c.
     
        SPREADINV(f,c) applies the inverse of the spreading operator with
        symbol c to the input signal f.
     
     *Url*: <http://ltfat.github.io/doc/operators/spreadinv.html>

     See also: spreadfun, tconv, spreadfun, spreadadj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
SPREADINV  Apply inverse spreading operator
   Usage: h=spreadinv(f,c);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
spreadop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1161
 -- Function: spreadop
     SPREADOP  Spreading operator
        Usage: h=spreadop(f,c);
     
        SPREADOP(f,c) applies the operator with spreading function c to the
        input f. c must be square.
     
        SPREADOP(f,c) computes the following for c of size L xL:
      
                   L-1 L-1 
          h(l+1) = sum sum c(m+1,n+1)*exp(2*pi*i*l*m/L)*f(l-n+1)
                   n=0 m=0
     
        where l=0,...,L-1 and l-n is computed modulo L.
     
        The combined symbol of two spreading operators can be found by using
        tconv. Consider two symbols c1 and c2 and define f1 and f2 by:
     
          h  = tconv(c1,c2)
          f1 = spreadop(spreadop(f,c2),c1);
          f2 = spreadop(f,h);
     
        then f1 and f2 are equal.
     
     
        References:
          H. G. Feichtinger and W. Kozek. Operator quantization on LCA groups. In
          H. G. Feichtinger and T. Strohmer, editors, Gabor Analysis and
          Algorithms, chapter 7, pages 233--266. Birkhauser, Boston, 1998.
          
     *Url*: <http://ltfat.github.io/doc/operators/spreadop.html>

     See also: tconv, spreadfun, spreadinv, spreadadj.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
SPREADOP  Spreading operator
   Usage: h=spreadop(f,c);





