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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2147
 LTFAT - Frames

  Peter L. Soendergaard, 2012 - 2023.

  Creation of a frame object
    FRAME             - Construct a new frame
    FRAMEPAIR         - Construct a pair of frames
    FUSIONFRAME       - Construct a new fusion frame
    FRAMEDUAL         - The canonical dual frame
    FRAMETIGHT        - The canonical tight frame
    FRAMEACCEL        - Precompute arrays for faster application

  Linear operators
    FRANA             - Frame analysis
    FRSYN             - Frame synthesis
    FRSYNMATRIX       - Frame synthesis operator matrix
    FRGRAMIAN	       - Frame Gramian operator
    FRAMEOPERATOR     - Frame operator
    FRAMEDIAG         - Diagonal of frame operator
    FRANAITER         - Iterative perfect reconstruction analysis
    FRSYNITER         - Iterative perfect reconstruction synthesis

  Visualization
    PLOTFRAME         - Plot frame coefficients
    FRAMEGRAM         - Plot energy of signal in frame space

  Information about a frame
    FRAMEBOUNDS       - Frame bounds
    FRAMERED          - Redundancy of frame
    FRAMELENGTH       - Length of frame to expand signal
    FRAMELENGTHCOEF   - Length of frame given a set of coefficients
    FRAMECLENGTH      - Number of coefficients given input signal length
    FRAMEVECTORNORMS  - Norms of the frame vectors

  Coefficients conversions
    FRAMECOEF2NATIVE  - Convert to native transform format
    FRAMENATIVE2COEF  - Convert native to column format
    FRAMECOEF2TF      - Convert to time-frequency plane layout
    FRAMETF2COEF      - Convert TF-plane layout to native
    FRAMECOEF2TFPLOT  - Convert to time-frequency plane layout for plotting

  Non-linear analysis and synthesis
    FRANABP           - Basis pursuit using the SALSA algorithm.
    FRANAMP           - Orthogonal matching pursuit
    FRANALASSO        - LASSO thresholding using Landweber iterations.
    FRANAGROUPLASSO   - Group LASSO thresholding.
    FRSYNABS          - Frame synthesis from magnitude of coefficients

  For help, bug reports, suggestions etc. please visit 
  http://github.com/ltfat/ltfat/issues

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
 LTFAT - Frames



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
frame


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6489
 -- Function: frame
     FRAME  Construct a new frame
        Usage: F=frame(ftype,...);
     
        F=FRAME(ftype,...) constructs a new frame object F of type
        ftype. Arguments following ftype are specific to the type of frame
        chosen.
     
        Time-frequency frames
        ---------------------
     
        FRAME('dgt',g,a,M) constructs a Gabor frame with window g,
        time-shift a and M channels. See the help on DGT for more
        information.
     
        FRAME('dgtreal',g,a,M) constructs a Gabor frame for real-valued
        signals with window g, time-shift a and M channels. See the help
        on DGTREAL for more information.
     
        FRAME('dwilt',g,M) constructs a Wilson basis with window g and M*
        channels. See the help on DWILT for more information.
     
        FRAME('wmdct',g,M) constructs a windowed MDCT basis with window g*
        and M channels. See the help on WMDCT for more information.
     
        FRAME('filterbank',g,a,M) constructs a filterbank with filters g,
        time-shifts of a and M channels. For the ease of implementation, it
        is necessary to specify M, even though it strictly speaking could be
        deduced from the size of the windows. See the help on FILTERBANK for
        more information on the parameters. Similarly, you can construct a
        uniform filterbank by selecting 'ufilterbank', a positive-frequency
        filterbank by selecting 'filterbankreal' or a uniform
        positive-frequency filterbank by selecting 'ufilterbankreal'.
     
        FRAME('nsdgt',g,a,M) constructs a non-stationary Gabor frame with
        filters g, time-shifts of a and M channels. See the help on
        NSDGT for more information on the parameters. Similarly, you can
        construct a uniform NSDGT by selecting 'unsdgt', an NSDGT for
        real-valued signals only by selecting 'nsdgtreal' or a
        uniform NSDGT for real-valued signals by selecting 'unsdgtreal'.
     
        Wavelet frames
        --------------
     
        FRAME('fwt', w, J) constructs a wavelet frame with wavelet definition 
        w and J number of filterbank iterations. Similarly, a redundant time 
        invariant wavelet representation can be constructed by selecting 'ufwt'.
        See the help on FWT and UFWT for more information.
     
        FRAME('wfbt', wt) constructs a wavelet filterbank tree defined by
        the wavelet filterbank tree definition wt. Similarly, an undecimated
        wavelet filterbank tree can be constructed by selecting 'uwfbt'. See the
        help on WFBT and UWFBT for more information.
     
        FRAME('wpfbt', wt) constructs a wavelet packet filterbank tree 
        defined by the wavelet filterbank tree definition wt. Similarly, an
        undecimated wavelet packet filterbank tree can be constructed by selecting
        'uwpfbt'. See the help on WPFBT and UWPFBT for more information.
     
        Pure frequency frames
        ---------------------
     
        FRAME('dft') constructs a basis where the analysis operator is the
        DFT, and the synthesis operator is its inverse, IDFT. Completely
        similar to this, you can enter the name of any of the cosine or sine
        transforms DCTI, DCTII, DCTIII, DCTIV, DSTI, DSTII,
        DSTIII or DSTIV.
     
        FRAME('reddft',red) constructs so called harmonic Parseval tight
        frame or redundant dft with redundancy red. The frame accepts any 
        red, but FRANA will only work for signal lengths Ls for which 
        the number of coefficients Ls*red is an integer.
     
        FRAME('dftreal') constructs a normalized FFTREAL basis for
        real-valued signals of even length only. The basis is normalized
        to ensure that is it orthonormal.
     
        Special / general frames
        ------------------------
     
        FRAME('gen',g) constructs a general frame with a synthesis matrix g.
        The frame atoms must be stored as column vectors in the matrix.
     
        FRAME('identity') constructs the canonical orthonormal basis, meaning
        that all operators return their input as output, so it is the dummy
        operation.
     
        Container frames
        ----------------
     
        FRAME('fusion',w,F1,F2,...) constructs a fusion frame, which is
        the collection of the frames specified by F1, F2,... The vector
        w contains a weight for each frame. If w is a scalar, this weight
        will be applied to all the sub-frames.
     
        FRAME('tensor',F1,F2,...) constructs a tensor product frame, where the
        frames F1, F2,... are applied along the 1st, 2nd etc. dimensions. If
        you don't want any action along a specific dimension, use the identity
        frame along that dimension. Any remaining dimensions in the input
        signal are left alone.
     
        Wrapper frames
        --------------
     
        Frames types in this section are "virtual". They serve as a wrapper for
        a different type of frame.
     
        FRAME('erbletfb',fs,Ls,...) constructs an Erb-let filterbank frame for
        a given samp. frequency fs working with signals of length Ls. See
        ERBFILTERS for a description of additional parameters as all 
        parameters other than the frame type string 'erbletfb' are passed to it.
        NOTE: The resulting frame is defined only for a single signal length
        Ls. Shorter signals will be zero-padded, signals longer than Ls*
        cannot be processed.
        The actual frame type is 'filterbank' or 'filterbankreal'.
     
        FRAME('cqtfb',fs,fmin,fmax,bins,Ls,...) constructs a CQT filterbank 
        frame for a given samp. frequency fs working with signals of length 
        Ls. See CQTFILTERS for a description of other parameters.
        NOTE: The resulting frame is defined only for a single signal length
        Ls. Shorter signals will be zero-padded, signals longer than Ls*
        cannot be processed.
        The actual frame type is 'filterbank' or 'filterbankreal'.
       
        Examples
        --------
     
        The following example creates a Modified Discrete Cosine Transform frame,
        analyses an input signal and plots the frame coefficients:
     
           F=frame('wmdct','gauss',40);
           c=frana(F,greasy);
           plotframe(F,c,'dynrange',60);
     
     *Url*: <http://ltfat.github.io/doc/frames/frame.html>

     See also: frana, frsyn, plotframe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
FRAME  Construct a new frame
   Usage: F=frame(ftype,...);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 924
 -- Function: frameaccel
     FRAMEACCEL  Precompute structures
        Usage: F=frameaccel(F,Ls);
     
        F=FRAMEACCEL(F,Ls) precomputes certain structures that makes the basic
        frame operations FRANA and FRSYN faster (like instantiating the
        window from a textual description). If you only need to call the
        routines once, calling FRAMEACCEL first will not provide any total
        gain, but if you are repeatedly calling these routines, for instance in
        an iterative algorithm, it will be a benefit.
     
        Notice that you need to input the signal length Ls, so this routines
        will only be a benefit if Ls stays fixed.
     
        If FRAMEACCEL is called twice for the same transform length, no
        additional computations will be done.
     
     *Url*: <http://ltfat.github.io/doc/frames/frameaccel.html>

     See also: frame, frana, framelength, framelengthcoef.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
FRAMEACCEL  Precompute structures
   Usage: F=frameaccel(F,Ls);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2543
 -- Function: framebounds
     FRAMEBOUNDS  Frame bounds
        Usage: fcond=framebounds(F);
               [A,B]=framebounds(F);
               [...]=framebounds(F,Ls);
     
        FRAMEBOUNDS(F) calculates the ratio B/A of the frame bounds of the
        frame given by F. The length of the system the frame bounds are
        calculated for is given by L=framelength(F,1).
     
        FRAMEBOUNDS(F,Ls) additionally specifies a signal length for which
        the frame should work. The actual length used is L=framelength(F,Ls).
     
        [A,B]=FRAMEBOUNDS(F) returns the frame bounds A and B instead of
        just their ratio.
     
     
        'framebounds` accepts the following optional parameters:
     
          'fac'        Use a factorization algorithm. The function will throw
                       an error if no algorithm is available.
     
          'iter'       Call eigs to use an iterative algorithm.
     
          'full'       Call eig to solve the full problem.
     
          'auto'       Choose the fac method if possible, otherwise
                       use the full method for small problems and the
                       iter method for larger problems. 
                       This is the default. 
     
          'crossover',c
                       Set the problem size for which the 'auto' method
                       switches between full and iter. Default is 200.
     
        The following parameters specifically related to the iter method: 
     
          'tol',t      Stop if relative residual error of eigs is less than the
                       specified tolerance. Default is 1e-9 
     
          'maxit',n    Do at most n iterations in eigs. Default is 100.
     
          'pcgtol',t   Stop if relative residual error of pcg is less than the
                       specified tolerance. Default is 1e-6 
     
          'pcgmaxit',n Do at most n iterations in pcg. Default is 150.
     
          'p',p        The number of Lanzcos basis vectors to use.  More vectors
                       will result in faster convergence, but a larger amount of
                       memory.  The optimal value of p is problem dependent and
                       should be less than L.  The default value chosen 
                       automatically by eigs.
      
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     
     *Url*: <http://ltfat.github.io/doc/frames/framebounds.html>

     See also: frame, framered.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEBOUNDS  Frame bounds
   Usage: fcond=framebounds(F);
          [A,B]=fra...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 756
 -- Function: frameclength
     FRAMECLENGTH  Number of coefficients from length of signal
        Usage: Ncoef=frameclength(F,Ls);
               [Ncoef,L]=frameclength(...);
     
        Ncoef=FRAMECLENGTH(F,Ls) returns the total number of coefficients 
        obtained by applying the analysis operator of frame F to a signal
        of length Ls i.e. size(frana(F,f),1) for Ls=length(f). 
     
        [Ncoef,L]=FRAMECLENGTH(F,Ls) additionally returns L, which is the 
        same as returned by FRAMELENGTH.
     
        If the frame length L is longer than the signal length Ls, the 
        signal will be zero-padded to L by FRANA.
     
     *Url*: <http://ltfat.github.io/doc/frames/frameclength.html>

     See also: frame, framelengthcoef.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMECLENGTH  Number of coefficients from length of signal
   Usage: Ncoef=fr...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
framecoef2native


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 466
 -- Function: framecoef2native
     FRAMECOEF2NATIVE  Convert coefficients to native format
        Usage: coef=framecoef2native(F,coef);
     
        FRAMECOEF2NATIVE(F,coef) converts the frame coefficients coef into 
        the native coefficient format of the frame. The frame object F must 
        have been created using FRAME.
     
     *Url*: <http://ltfat.github.io/doc/frames/framecoef2native.html>

     See also: frame, framenative2coef, framecoef2tf.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMECOEF2NATIVE  Convert coefficients to native format
   Usage: coef=framec...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 851
 -- Function: framecoef2tf
     FRAMECOEF2TF  Convert coefficients to time-frequency plane
        Usage: cout=framecoef2tf(F,cin);
     
        FRAMECOEF2TF(F,cin) converts the frame coefficients cin into the
        time-frequency plane layout. The frame object F must have been
        created using FRAME.
     
        The time-frequency plane layout is a matrix, where the first
        dimension indexes frequency and the second dimension time. This is
        similar to the output format from DGT and WMDCT.
     
        Not all types of frames support this coefficient conversion. The supported 
        types of frames are: 'dgt', 'dgtreal', 'dwilt', 'wmdct', 'ufilterbank',
        'ufwt','uwfbt' and 'uwpfbt'.
     
     *Url*: <http://ltfat.github.io/doc/frames/framecoef2tf.html>

     See also: frame, frametf2coef, framecoef2native.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMECOEF2TF  Convert coefficients to time-frequency plane
   Usage: cout=fra...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
framecoef2tfplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 740
 -- Function: framecoef2tfplot
     FRAMECOEF2TFPLOT  Convert coefficients to time-frequency plane matrix
        Usage: cout=framecoef2tfplot(F,cin);
     
        FRAMECOEF2TFPLOT(F,coef) converts the frame coefficients coef into
        the time-frequency plane layout matrix. The frame object F must have 
        been created using FRAME. The function acts exactly as 
        FRAMECOEF2TF for frames which admit regular (rectangular) sampling
        of a time-frequency plane and converts irregularly sampled coefficients
        to a rectangular matrix. This is usefull for custom plotting.
     
     *Url*: <http://ltfat.github.io/doc/frames/framecoef2tfplot.html>

     See also: frame, frametf2coef, framecoef2native, blockplot.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMECOEF2TFPLOT  Convert coefficients to time-frequency plane matrix
   Usag...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 441
 -- Function: framediag
     FRAMEDIAG  Compute the diagonal of the frame operator
        Usage: d=framediag(F,L);
     
        FRAMEDIAG(F,L) computes the diagonal of the frame operator for a
        frame of type F of length L.
     
        The diagonal of the frame operator can for instance be used as a
        preconditioner.
     
     *Url*: <http://ltfat.github.io/doc/frames/framediag.html>

     See also: franaiter, frsyniter.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEDIAG  Compute the diagonal of the frame operator
   Usage: d=framediag(F...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 730
 -- Function: framedual
     FRAMEDUAL  Construct the canonical dual frame
        Usage: Fd=framedual(F);
     
        Fd=FRAMEDUAL(F) returns the canonical dual frame of F.
     
        The canonical dual frame can be used to get perfect reconstruction as in
        the following example:
     
          % Create a frame and its canonical dual
          F=frame('dgt','hamming',32,64);
          Fd=framedual(F);
     
          % Compute the frame coefficients and test for perfect
          % reconstruction
          f=gspi;
          c=frana(F,f);
          r=frsyn(Fd,c);
          norm(r(1:length(f))-f)
     
     *Url*: <http://ltfat.github.io/doc/frames/framedual.html>

     See also: frame, framepair, frametight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
FRAMEDUAL  Construct the canonical dual frame
   Usage: Fd=framedual(F);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 544
 -- Function: framegram
     FRAMEGRAM  Easy visualization of energy in transform domain
        Usage: framegram(F,x,...);
     
        FRAMEGRAM(F,x) plots the energy of the frame coefficients computed
        from the input signal x using the frame F for analysis. This is
        just a shorthand for:
     
          plotframe(F,abs(frana(F,x)).^2);
     
        Any additional arguments given to FRAMEGRAM are passed onto
        PLOTFRAME.
     
     *Url*: <http://ltfat.github.io/doc/frames/framegram.html>

     See also: plotframe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEGRAM  Easy visualization of energy in transform domain
   Usage: framegr...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 561
 -- Function: framelength
     FRAMELENGTH  Frame length from signal
        Usage: L=framelength(F,Ls);
     
        FRAMELENGTH(F,Ls) returns the length of the frame F, such that
        F is long enough to expand a signal of length Ls.
     
        If the frame length is longer than the signal length, the signal will be
        zero-padded by FRANA.
     
        If instead a set of coefficients are given, call FRAMELENGTHCOEF.
     
     *Url*: <http://ltfat.github.io/doc/frames/framelength.html>

     See also: frame, framelengthcoef, frameclength.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
FRAMELENGTH  Frame length from signal
   Usage: L=framelength(F,Ls);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
framelengthcoef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 451
 -- Function: framelengthcoef
     FRAMELENGTHCOEF  Frame length from coefficients
        Usage: L=framelengthcoef(F,Ncoef);
     
        FRAMELENGTHCOEF(F,Ncoef) returns the length of the frame F, such that
        F is long enough to expand the coefficients of length Ncoef.
     
        If instead a signal is given, call FRAMELENGTH.
     
     *Url*: <http://ltfat.github.io/doc/frames/framelengthcoef.html>

     See also: frame, framelength.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMELENGTHCOEF  Frame length from coefficients
   Usage: L=framelengthcoef(F...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
framenative2coef


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 406
 -- Function: framenative2coef
     FRAMENATIVE2COEF  Convert coefficient from native format
        Usage: coef=framenative2coef(F,coef);
     
        FRAMENATIVE2COEF(F,coef) converts the frame coefficients from the 
        native format of the transform into the common column format.
     
     *Url*: <http://ltfat.github.io/doc/frames/framenative2coef.html>

     See also: frame, framecoef2native.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMENATIVE2COEF  Convert coefficient from native format
   Usage: coef=frame...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
frameoperator


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 708
 -- Function: frameoperator
     FRAMEOPERATOR Frame Operator
        Usage:  o=frameoperator(F, f);
     
        Input parameters:
               F    : frame
               f    : input vector
     
        Output parameter: 
               h    : output vector
          
        h=FRAMEOPERATOR(F,f) applies the frame operator associated with the frame 
        F to the input f.
     
        If the frame F is a tight frame, then h equals f up to the constant 
        frac{1}{A} where A is the lower frame bound of F. If the frame F*
        is an orthonormal basis, or more general a Parseval frame, then h equals 
        f. 
     
     *Url*: <http://ltfat.github.io/doc/frames/frameoperator.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
FRAMEOPERATOR Frame Operator
   Usage:  o=frameoperator(F, f);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1301
 -- Function: framepair
     FRAMEPAIR  Construct a new frame
        Usage: [F1,F2]=framepair(ftype,g1,g2,...);
     
        [F1,F2]=FRAMEPAIR(ftype,g1,g2,...) constructs two new frame objects 
        F1 and F2 of the same type ftype using the windows g1 and g2.
        The windows are specific to choosen frame type. See the help on frame*
        for the windows and arguments. 
     
        This function makes it easy to create a pair of canonical dual frames:
        simply specify 'dual' as window if one frame should be the dual of the
        other.
     
        This is most easily explained through some examples. The following
        example creates a Gabor frame for real-valued signals with a Gaussian
        analysis window and its canonical dual frame as the synthesis frame:
     
           f=greasy;
           [Fa,Fs]=framepair('dgtreal','gauss','dual',20,294);
           c=frana(Fa,f);
           r=frsyn(Fs,c);
           norm(f-r)
     
        The following example creates a Wilson basis with a Gaussian
        synthesis window, and its canonical dual frame as the analysis
        frame:
      
          [Fa,Fs]=framepair('dwilt','dual','gauss',20);
     
     *Url*: <http://ltfat.github.io/doc/frames/framepair.html>

     See also: frame, framedual, frametight.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
FRAMEPAIR  Construct a new frame
   Usage: [F1,F2]=framepair(ftype,g1,g2,...);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 803
 -- Function: framered
     FRAMERED  Redundancy of a frame
        Usage  red=framered(F);
     
        FRAMERED(F) computes the redundancy of a given frame F. If the
        redundancy is larger than 1 (one), the frame transform will produce more
        coefficients than it consumes. If the redundancy is exactly 1 (one),
        the frame is a basis.
     
        Examples:
        ---------
     
        The following simple example shows how to obtain the redundancy of a
        Gabor frame:
     
          F=frame('dgt','gauss',30,40);
          framered(F)
     
        The redundancy of a basis is always one:
     
          F=frame('wmdct','gauss',40);
          framered(F)
     
     *Url*: <http://ltfat.github.io/doc/frames/framered.html>

     See also: frame, frana, framebounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
FRAMERED  Redundancy of a frame
   Usage  red=framered(F);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 604
 -- Function: frametf2coef
     FRAMETF2COEF  Convert coefficients from TF-plane format
        Usage: cout=frametf2coef(F,cin);
     
        FRAMETF2COEF(F,cin) converts the frame coefficients from the
        time-frequency plane layout into the common column format.
     
        Not all types of frames support this coefficient conversion. The supported 
        types of frames are: 'dgt', 'dgtreal', 'dwilt', 'wmdct', 'ufilterbank',
        'ufwt','uwfbt' and 'uwpfbt'.
     
     *Url*: <http://ltfat.github.io/doc/frames/frametf2coef.html>

     See also: frame, framecoef2tf, framecoef2native.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMETF2COEF  Convert coefficients from TF-plane format
   Usage: cout=framet...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 813
 -- Function: frametight
     FRAMETIGHT  Construct the canonical tight frame
        Usage: Ft=frametight(F);
     
        Ft=FRAMETIGHT(F) returns the canonical tight frame of F.
     
        The canonical tight frame can be used to get perfect reconstruction if
        it is used for both analysis and synthesis. This is demonstrated in the
        following example:
     
          % Create a frame and its canonical tight
          F=frame('dgt','hamming',32,64);
          Ft=frametight(F);
     
          % Compute the frame coefficients and test for perfect
          % reconstruction
          f=gspi;
          c=frana(Ft,f);
          r=frsyn(Ft,c);
          norm(r(1:length(f))-f)
     
     *Url*: <http://ltfat.github.io/doc/frames/frametight.html>

     See also: frame, framepair, framedual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
FRAMETIGHT  Construct the canonical tight frame
   Usage: Ft=frametight(F);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
framevectornorms


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1426
 -- Function: framevectornorms
     FRAMEVECTORNORMS  Norm of frame vectors 
        Usage: vnorms = framevectornorms(F,L)
               vnorms = framevectornorms(F,L,idx)
     
        Input parameters:
            F        : Frame definition
            L        : System length
            idx      : Index (or range) of vector(s)
        Output parameters:
            vnorms   : Vector norms
     
        FRAMEVECTORNORMS(F,L) returns 2-norms of vectors of frame F for
        system length L. The number of vectors in a frame (and the length of
        the output vector) can be obtained as frameclength(F,L).
     
        FRAMEVECTORNORMS(F,L,idx) returns 2-norms of vectors with indices 
        idx. Elements in idx must be in range 1:frameclength(F,L).
     
        Real-valued-input frames
        ------------------------
     
        By default, the function returns the norm of vectors used for
        synthesis. Frames like 'dgtreal', 'filterbankreal' do not contain the 
        ''redundant'' conjugate-symmetric vectors and their synthesis operator
        is not linear. Therefore the vectors used in synthesis do not have 
        an explicit form and their norm is unspecified. The vectors used for 
        analysis are well defined and can be obtained by passing additional
        flag 'ana'.
     
     *Url*: <http://ltfat.github.io/doc/frames/framevectornorms.html>

     See also: frsynmatrix.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEVECTORNORMS  Norm of frame vectors 
   Usage: vnorms = framevectornorms(...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
frana


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1321
 -- Function: frana
     FRANA  Frame analysis operator
        Usage: c=frana(F,f);
     
        c=FRANA(F,f) computes the frame coefficients c of the input
        signal f using the frame F. The frame object F must have been
        created using FRAME or FRAMEPAIR.
     
        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.
     
        The output coefficients are stored as columns. This is usually
        *not* the same format as the 'native' format of the frame. As an
        examples, the output from FRANA for a gabor frame cannot be
        passed to IDGT without a reshape.
     
        Examples:
        ---------
     
        In the following example the signal bat is analyzed through a wavelet 
        frame. The result are the frame coefficients associated with the input  
        signal bat and the analysis frame 'fwt':
     
           f = bat;
           w = 'sym8';
           J = 7;
           F = frame('fwt', w, J); 
           c = frana(F, f);
           % A plot of the frame coefficients
           plotframe(F, c, 'dynrange', 100);
     
     *Url*: <http://ltfat.github.io/doc/frames/frana.html>

     See also: frame, framepair, frsyn, plotframe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
FRANA  Frame analysis operator
   Usage: c=frana(F,f);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
franabp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6373
 -- Function: franabp
     FRANABP Frame Analysis Basis Pursuit
        Usage: c = franabp(F,f)
               c = franabp(F,f,lambda,C,tol,maxit)
               [c,relres,iter,frec,cd] = franabp(...)
     
        Input parameters:
            F        : Frame definition
            f        : Input signal
            lambda   : Regularisation parameter.
            C        : Step size of the algorithm.
            tol      : Reative error tolerance.
            maxit    : Maximum number of iterations.
        Output parameters:
            c        : Sparse coefficients.
            relres   : Last relative error.
            iter     : Number of iterations done.
            frec     : Reconstructed signal such that frec = frsyn(F,c)
            cd       : The min c||_2 solution using the canonical dual frame.
     
        c = FRANABP(F,f) solves the basis pursuit problem
     
           argmin ||c||_1 subject to Fc = f
     
        for a general frame F using SALSA (Split Augmented Lagrangian
        Srinkage algorithm) which is an appication of ADMM (Alternating
        Direction Method of Multipliers) to the basis pursuit problem.
     
        The algorithm given F and f and parameters C >0, lambda >0 
        (see below) acts as follows:
     
          Initialize c,d
          repeat
            v <- soft(c+d,lambda/C) - d
            d <- F*(FF*)^(-1)(f - Fv)
            c <- d + v
          end
     
        When compared to other algorithms, Fc = f holds exactly (up to a num.
        prec) in each iteration.
     
        For a quick execution, the function requires analysis operator of the
        canonical dual frame F*(FF*)^(-1). By default, the function attempts
        to call FRAMEDUAL to create the canonical dual frame explicitly.
        If it is not available, the conjugate gradient method algorithm is
        used for inverting the frame operator in each iteration of the
        algorithm.
        Optionally, the canonical dual frame object or an anonymous function 
        acting as the analysis operator of the canonical dual frame can be 
        passed as a key-value pair 'Fd',Fd see below. 
     
        Optional positional parameters (lambda,C,tol,maxit)
        ---------------------------------------------------
     
        lambda
            A parameter for weighting coefficients in the objective
            function. For lambda~=1 the basis pursuit problem changes to
     
               argmin ||lambda c||_1 subject to Fc = f
     
            lambda can either be a scalar or a vector of the same length
            as c (in such case the product is carried out elementwise). 
            One can obtain length of c from length of f by
            FRAMECLENGTH. FRAMECOEF2NATIVE and FRAMENATIVE2COEF will
            help with defining weights specific to some regions of
            coefficients (e.g. channel-specific weighting can be achieved
            this way).           
            The default value of lambda is 1.
     
        C
           A step parameter of the SALSA algorithm. 
           The default value of C is the upper frame bound of F. 
           Depending on the structure of the frame, this can be an expensive
           operation.
     
        tol
           Defines tolerance of relres which is a norm or a relative
           difference of coefficients obtained in two consecutive iterations
           of the algorithm.
           The default value 1e-2.
     
        maxit
           Maximum number of iterations to do.
           The default value is 100.
     
        Other optional parameters
        -------------------------
     
        Key-value pairs:
     
        'Fd',Fd
           A canonical dual frame object or an anonymous function 
           acting as the analysis operator of the canonical dual frame.
     
        'printstep',printstep
           Print current status every printstep iteration.
     
        Flag groups (first one listed is the default):
     
        'print','quiet'
            Enables/disables printing of notifications.
     
        'zeros','frana'
           Starting point of the algorithm. With 'zeros' enabled, the
           algorithm starts from coefficients set to zero, with 'frana'
           the algorithm starts from c=frana(F,f).             
     
        Returned arguments:
        -------------------
     
        [c,relres,iter] = FRANABP(...) returns the residuals relres in a
        vector and the number of iteration steps done iter.
     
        [c,relres,iter,frec,cd] = FRANABP(...) returns the reconstructed
        signal from the coefficients, frec (this requires additional
        computations) and a coefficients cd minimising the c||_2 norm
        (this is a byproduct of the algorithm).
     
        The relationship between the output coefficients frec and c is
        given by :
     
          frec = frsyn(F,c);
     
        And cd and f by :
     
          cd = frana(framedual(F),f);
     
        Examples:
        ---------
     
        The following example shows how FRANABP produces a sparse
        representation of a test signal greasy still maintaining a perfect
        reconstruction:
     
           f = greasy;
           % Gabor frame with redundancy 8
           F = frame('dgtreal','gauss',64,512);
           % Solve the basis pursuit problem
           [c,~,~,frec,cd] = franabp(F,f);
           % Plot sparse coefficients
           figure(1);
           plotframe(F,c,'dynrange',50);
     
           % Plot coefficients obtained by applying an analysis operator of a
           % dual Gabor system to f*
           figure(2);
           plotframe(F,cd,'dynrange',50);
     
           % Check the reconstruction error (should be close do zero).
           % frec is obtained by applying the synthesis operator of frame F*
           % to sparse coefficients c.
           norm(f-frec)
     
           % Compare decay of coefficients sorted by absolute values
           % (compressibility of coefficients)
           figure(3);
           semilogx([sort(abs(c),'descend')/max(abs(c)),...
           sort(abs(cd),'descend')/max(abs(cd))]);
           legend({'sparsified coefficients','dual system coefficients'});
     
     *Url*: <http://ltfat.github.io/doc/frames/franabp.html>

     See also: frame, frana, frsyn, framebounds, franalasso.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANABP Frame Analysis Basis Pursuit
   Usage: c = franabp(F,f)
          c =...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
franagrouplasso


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4286
 -- Function: franagrouplasso
     FRANAGROUPLASSO  Group LASSO regression in the TF-domain
        Usage: tc = franagrouplasso(F,f,lambda)
               tc = franagrouplasso(F,f,lambda,C,tol,maxit)
               [tc,relres,iter,frec] = franagrouplasso(...)
     
        Input parameters:
           F        : Frame definition
           f        : Input signal
           lambda   : Regularisation parameter, controls sparsity of the solution
           C        : Step size of the algorithm.
           tol      : Reative error tolerance.
           maxit    : Maximum number of iterations.
        Output parameters:
           tc        : Thresholded coefficients
           relres    : Vector of residuals.
           iter      : Number of iterations done.
           frec      : Reconstructed signal
     
        FRANAGROUPLASSO(F,f,lambda) solves the group LASSO regression problem
        in the time-frequency domain: minimize a functional of the synthesis
        coefficients defined as the sum of half the l^2 norm of the
        approximation error and the mixed l^1 / l^2 norm of the coefficient
        sequence, with a penalization coefficient lambda.
       
        The matrix of time-frequency coefficients is labelled in terms of groups
        and members.  By default, the obtained expansion is sparse in terms of
        groups, no sparsity being imposed to the members of a given group. This
        is achieved by a regularization term composed of l^2 norm within a
        group, and l^1 norm with respect to groups. See the help on
        GROUPTHRESH for more information.
     
        *Note* the involved frame F must support regular time-frequency
        layout of coefficients.   
     
        [tc,relres,iter] = FRANAGROUPLASSO(...) returns the residuals relres in
        a vector and the number of iteration steps done, maxit.
     
        [tc,relres,iter,frec] = FRANAGROUPLASSO(...) returns the reconstructed
        signal from the coefficients, frec. Note that this requires additional
        computations.
     
        The function takes the following optional parameters at the end of
        the line of input arguments:
     
          'freq'     Group in frequency (search for tonal components). This is the
                     default.
     
          'time'     Group in time (search for transient components). 
     
          'C',cval   Landweber iteration parameter: must be larger than
                     square of upper frame bound. Default value is the upper
                     frame bound.
     
          'maxit',maxit
                     Stopping criterion: maximal number of iterations. 
                     Default value is 100.
     
          'tol',tol  Stopping criterion: minimum relative difference between
                     norms in two consecutive iterations. Default value is
                     1e-2.
     
          'print'    Display the progress.
     
          'quiet'    Don't print anything, this is the default.
     
          'printstep',p
                     If 'print' is specified, then print every p'th
                     iteration. Default value is 10;
     
        In addition to these parameters, this function accepts all flags from
        the GROUPTHRESH and THRESH functions. This makes it possible to
        switch the grouping mechanism or inner thresholding type.
     
        The parameters C, maxit and tol may also be specified on the
        command line in that order: FRANAGROUPLASSO(F,x,lambda,C,tol,maxit).
     
        The solution is obtained via an iterative procedure, called Landweber
        iteration, involving iterative group thresholdings.
     
        The relationship between the output coefficients is given by :
     
          frec = frsyn(F,tc);
     
     
        References:
          M. Kowalski. Sparse regression using mixed norms. Appl. Comput. Harmon.
          Anal., 27(3):303--324, 2009.
          
          M. Kowalski and B. Torresani. Sparsity and persistence: mixed norms
          provide simple signal models with dependent coefficients. Signal, Image
          and Video Processing, 3(3):251--264, 2009.
          
     *Url*: <http://ltfat.github.io/doc/frames/franagrouplasso.html>

     See also: franalasso, framebounds.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANAGROUPLASSO  Group LASSO regression in the TF-domain
   Usage: tc = frana...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2390
 -- Function: franaiter
     FRANAITER  Iterative analysis
        Usage:  c=franaiter(F,f);
                [c,relres,iter]=franaiter(F,f,...);
     
        Input parameters:
              F       : Frame.
              f       : Signal.
              Ls      : Length of signal.
        Output parameters:
              c       : Array of coefficients.    
              relres  : Vector of residuals.
              iter    : Number of iterations done.
     
        c=FRANAITER(F,f) computes the frame coefficients c of the signal f*
        using an iterative method such that perfect reconstruction can be
        obtained using FRSYN. FRANAITER always works, even when FRANA
        cannot generate perfect reconstruction coefficients.
     
        [c,relres,iter]=FRANAITER(...) additionally returns the relative
        residuals in a vector relres and the number of iteration steps iter.
       
        *Note:* If it is possible to explicitly calculate the canonical dual
        frame then this is usually a much faster method than invoking
        FRANAITER.
     
        FRANAITER 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 (1e-5 for single precision)
     
          'maxit',n    Do at most n iterations.
     
          'pg'        Solve the problem using the Conjugate Gradient
                       algorithm. This is the default.
     
          'pcg'        Solve the problem using the Preconditioned Conjugate Gradient
                       algorithm.
     
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     
        Examples
        --------
     
        The following example shows how to rectruct a signal without ever
        using the dual frame:
     
           f=greasy;
           F=frame('dgtreal','gauss',40,60);
           [c,relres,iter]=franaiter(F,f,'tol',1e-14);
           r=frsyn(F,c);
           norm(f-r)/norm(f)
           semilogy(relres);
           title('Conversion rate of the CG algorithm');
           xlabel('No. of iterations');
           ylabel('Relative residual');
     
     *Url*: <http://ltfat.github.io/doc/frames/franaiter.html>

     See also: frame, frana, frsyn, frsyniter.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANAITER  Iterative analysis
   Usage:  c=franaiter(F,f);
           [c,relr...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6431
 -- Function: franalasso
     FRANALASSO  Frame LASSO regression
        Usage: tc = franalasso(F,f,lambda)
               tc = franalasso(F,f,lambda,C,tol,maxit)
               [tc,relres,iter,frec,cd] = franalasso(...)
     
        Input parameters:
            F        : Frame definition
            f        : Input signal
            lambda   : Regularisation parameter, controls sparsity of the solution
            C        : Step size of the algorithm.
            tol      : Reative error tolerance.
            maxit    : Maximum number of iterations.
        Output parameters:
            tc       : Thresholded coefficients
            relres   : Vector of residuals.
            iter     : Number of iterations done.  
            frec     : Reconstructed signal
            cd       : The min c||_2 solution using the canonical dual frame.
     
        FRANALASSO(F,f,lambda) solves the LASSO (or basis pursuit denoising)
        regression problem for a general frame: minimize a functional of the
        synthesis coefficients defined as the sum of half the l^2 norm of the
        approximation error and the l^1 norm of the coefficient sequence, with
        a penalization coefficient lambda such that
     
           argmin lambda||c||_1 + 1/2||Fc - f||_2^2
     
        The solution is obtained via an iterative procedure, called Landweber
        iteration, involving iterative soft thresholdings.
     
        The following flags determining an algorithm to be used are recognized
        at the end of the argument list:
     
        'ista'
          The basic (Iterative Soft Thresholding) algorithm given F and f 
          and parameters C*>0, lambda >0 acts as follows:
     
             Initialize c
             repeat until stopping criterion is met
               c <- soft(c + F*(f - Fc)/C,lambda/C)
             end
     
        'fista'
          The fast version of the previous. This is the default option.
          :
     
             Initialize c(0),z,tau(0)=1,n=1
             repeat until stopping criterion is met
                c(n) <- soft(z + F*(f - Fz)/C,lambda/C)
                tau(n) <- (1+sqrt(1+4*tau(n-1)^2))/2
                z   <- c(n) + (c(n)-c(n-1))(tau(n-1)-1)/tau(n)
                n   <- n + 1
             end
     
        [tc,relres,iter] = FRANALASSO(...) returns the residuals relres in 
        a vector and the number of iteration steps done iter.
     
        [tc,relres,iter,frec,cd] = FRANALASSO(...) returns the reconstructed
        signal from the coefficients, frec and coefficients cd obtained by
        analysing using the canonical dual system. 
        Note that this requires additional computations.
     
        The relationship between the output coefficients and frec is 
        given by :
     
          frec = frsyn(F,tc);
     
        The function takes the following optional parameters at the end of
        the line of input arguments:
     
        'C',cval   
           Landweber iteration parameter: must be larger than square of upper 
           frame bound. Default value is the upper frame bound.
     
        'tol',tol  
           Stopping criterion: minimum relative difference between norms in 
           two consecutive iterations. Default value is 1e-2.
     
        'maxit',maxit
           Stopping criterion: maximal number of iterations to do. Default 
           value is 100.
     
        'print'    
           Display the progress.
     
        'quiet'    
           Don't print anything, this is the default.
     
        'printstep',p
           If 'print' is specified, then print every p'th iteration. Default 
           value is 10;
     
        'debias'
           Performs debiasing (improves approximation accuracy) of the solution
           using the conjugate gradient algorithm. This amounts to doing 
           best-fit with respect to a subdictionary selected by ISTA. 
     
        'pcgmaxit',pcgmaxit 
           Maximum allowed number of iterations for pcg. Only used together
           with the 'debias' flag. The default value is 100.
        
        'pcgtol',pcgtol 
           Tolerance of pcg. Only used together with the 'debias' flag. 
           The default value is 1e-6.
     
        The parameters C, itermax and tol may also be specified on the
        command line in that order: FRANALASSO(F,x,lambda,C,tol,maxit).
     
        *Note**: If you do not specify C, it will be obtained as the upper
        framebound. Depending on the structure of the frame, this can be an
        expensive operation.
     
        Examples:
        ---------
     
        The following example shows how FRANALASSO produces a sparse
        representation of a test signal greasy*:
     
           f = greasy;
           % Gabor frame with redundancy 8
           F = frame('dgtreal','gauss',64,512);
           % Choosing lambda (weight of the sparse regularization param.)
           lambda = 0.1;
           % Solve the basis pursuit problem
           [c1,~,~,frec1,cd] = franalasso(F,f,lambda);
           % Solve again with debiasing enabled
           [c2,~,~,frec2,cd] = franalasso(F,f,lambda,'debias');
           % Plot sparse coefficients
           figure(1); plotframe(F,c1,'dynrange',50);
           % Plot debiased coefficients
           figure(2); plotframe(F,c2,'dynrange',50);
           % Plot coefficients obtained by applying an analysis operator of a
           % dual Gabor system to f
           figure(3); plotframe(F,cd,'dynrange',50);
     
           % Normalized MSE of the approximation
           % frec is obtained by applying the synthesis operator of frame F
           % to sparse coefficients c.
           fprintf('Normalized MSE:                  %.2f dBn',20*log10(norm(f-frec1)/norm(f)));
           fprintf('Normalized MSE (with debiasing): %.2f dBn',20*log10(norm(f-frec2)/norm(f)));
     
           % Compare decay of coefficients sorted by absolute values
           % (compressibility of coefficients)
           figure(3);
           semilogx([sort(abs(c1),'descend')/max(abs(c1)),...
           sort(abs(c2),'descend')/max(abs(c2)),...
           sort(abs(cd),'descend')/max(abs(cd))]);
           legend({'sparsified coefficients','with debiasing','dual system coefficients'});
       
     *Url*: <http://ltfat.github.io/doc/frames/franalasso.html>

     See also: frame, frsyn, framebounds, franabp, franagrouplasso.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANALASSO  Frame LASSO regression
   Usage: tc = franalasso(F,f,lambda)
    ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
franamp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3653
 -- Function: franamp
     FRANAMP  Frame Analysis by Matching Pursuit
        Usage:  c = franamp(F,f)
                c = franamp(F,f,errdb,maxit)
                [c,frec,info] = franamp(...)
     
        Input parameters:
            F        : Frame definition
            f        : Input signal
            errdb    : Target normalized approximation error in dB
            maxit    : Maximum number of iterations.
        Output parameters:
            c        : Sparse representation
            frec     : Reconstructed signal
            info     : Struct with additional output paramerets
     
        FRANAMP(F,f) returns sparse representation of a signal in a
        dictionary given by vectors of frame F using the orthogonal matching
        pursuit algorithm.
     
        FRANAMP(F,f,errdb,maxit) tries to reach normalized approximation error 
        errdb dB in at most maxit iterations. 
     
        [c,frec,info] = FRANAMP(...) in addition returns the aproximated
        signal frec and a struct info with the following fields:
     
          .iter    Number of iterations done.
     
          .relres  Vector of length .iter with approximation error progress. 
     
        The normalized approximation error is computed as 
        err=norm(f-frec)/norm(f). The relationship between the output 
        coefficients and the approximation is frec = frsyn(F,c).
     
        The function takes the following optional parameters at the end of
        the line of input arguments:
     
          'print'    Display the progress.
     
          'printstep',p
                     If 'print' is specified, then print every p'th
                     iteration. Default value is 10;
     
        Algorithms
        ----------
     
        The implementation of OMP was taken from the sparsify_0.5 toolbox by
        Thomas Blumensath 
        http://www.personal.soton.ac.uk/tb1m08/sparsify/sparsify.html
        See help of greed_omp.
        In fact, the sparsify toolbox implements several flavors of OMP
        implementation. They can be chosen using the following flags:
     
          'auto'  Selects a suitable OMP algorithm according to the size of the problem.
     
          'qr'    QR based method
     
          'chol'  Cholesky based method
     
          'cg'    Conjugate Gradient Pursuit
     
        Additionally:
     
          'mp'    Classical (non-orthogonal) matching pursuit.
     
        Examples
        --------
     
        The following example show the development of the approx. error for the
        MP and OMP algorithms. :
     
            [f,fs] = greasy; F = frame('dgt','hann',256,1024);
            maxit = 4000;
            [c1,~,info1] = franamp(F,f,'omp','cg','maxit',maxit);
            [c2,~,info2] = franamp(F,f,'mp','maxit',maxit);
            plot(20*log10([info1.relres,info2.relres]));
            legend({'OMP','MP'});
     
     
        References:
          S. Mallat and Z. Zhang. Matching pursuits with time-frequency
          dictionaries. IEEE Trans. Signal Process., 41(12):3397--3415, 1993.
          
          Y. C. Pati, R. Rezaiifar, and P. S. Krishnaprasad. Orthogonal matching
          pursuit: Recursive function approximation with applications to wavelet
          decomposition. In Proc. 27th Asilomar Conference on Signals, Systems
          and Computers, pages 40--44 vol.1, Nov 1993.
          
          T. Blumensath and M. E. Davies. Gradient pursuits. IEEE Tran. Signal
          Processing, 56(6):2370--2382, 2008.
          
     *Url*: <http://ltfat.github.io/doc/frames/franamp.html>

     See also: frame, frsyn, framevectornorms.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANAMP  Frame Analysis by Matching Pursuit
   Usage:  c = franamp(F,f)
     ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1363
 -- Function: frgramian
     FRGRAMIAN Frame Gramian operator
        Usage:  o=frgramian(c, F);
                o=frgramian(c, Fa, Fs);
     
        Input parameters:
               c    : Input coefficients
               Fa   : Analysis frame
               Fs   : Synthesis frame
     
        Output parameters: 
               o    : Output coefficients
          
        o=FRGRAMIAN(c,F) applies the Gramian operator or Gram matrix of the 
        frame F. The entries of the Gram matrix are the inner products of the 
        frame elements of F. The frame must have been created using FRAME.
        If the frame F is a Parseval frame, the Gramian operator is a projection 
        onto the range of the frame analysis operator.
     
        o=FRGRAMIAN(c, Fa, Fs) applies the (cross) Gramian operator with the 
        frames Fa and Fs. Here Fs is the frame associated with the frame
        synthesis operator and Fa the frame that is associated with the 
        frame analysis operator. The entries of the matrix that is constructed
        through the Gramian operator are the inner products of the frame 
        elements of Fa and Fs.
        If Fa and Fs are canonical dual frames, the Gramian operator is a 
        projection onto the range of the frame analysis operator.
     
     *Url*: <http://ltfat.github.io/doc/frames/frgramian.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRGRAMIAN Frame Gramian operator
   Usage:  o=frgramian(c, F);
           o=f...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
frsyn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 974
 -- Function: frsyn
     FRSYN  Frame synthesis operator
        Usage: f=frsyn(F,c);
     
        f=FRSYN(F,c) constructs a signal f from the frame coefficients c*
        using the frame F. The frame object F must have been created using
        FRAME.
     
        Examples:
        ---------
     
        In the following example a signal f is constructed through the frame
        synthesis operator using a Gabor frame. The coefficients associated with 
        this Gabor expansion are contained in an identity matrix. The identity 
        matrix corresponds to a diagonal in the time-frequency plane, that is, 
        one atom at each time position with increasing frequency.:
     
           a = 10;
           M = 40;
     
           F = frame('dgt', 'gauss', a, M);
     
           c = framenative2coef(F, eye(40));
     
           f = frsyn(F, c);
     
     *Url*: <http://ltfat.github.io/doc/frames/frsyn.html>

     See also: frame, frana, plotframe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
FRSYN  Frame synthesis operator
   Usage: f=frsyn(F,c);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5071
 -- Function: frsynabs
     FRSYNABS  Reconstruction from magnitude of coefficients
        Usage:  f=frsynabs(F,s);
                f=frsynabs(F,s,Ls);
                [f,relres,iter,c]=frsynabs(...);
     
        Input parameters:
              F       : Frame
              s       : Array of coefficients.
              Ls      : length of signal.
        Output parameters:
              f       : Signal.
              relres  : Vector of residuals.
              iter    : Number of iterations done.
              c       : Coefficients with the reconstructed phase
     
        FRSYNABS(F,s) attempts to find a signal which has s as the absolute
        value of its frame coefficients :
     
          s = abs(frana(F,f));
     
        using an iterative method.
     
        FRSYNABS(F,s,Ls) does as above but cuts or extends f to length Ls.
     
        If the phase of the coefficients s is known, it is much better to use
        frsyn.
     
        [f,relres,iter]=FRSYNABS(...) additionally returns the residuals in a
        vector relres and the number of iteration steps iter. The residuals
        are computed as:
     
           relres = norm(abs(cn)-s,'fro')/norm(s,'fro')
     
        where c_n is the Gabor coefficients of the signal in iteration n.
     
        [f,relres,iter,c]=FRSYNABS(...,'griflim'|'fgriflim') additionally returns
        coefficients c with the reconstructed phase prior to the final reconstruction.
        This is usefull for determining the consistency (energy lost in the nullspace
        of F) of the reconstructed spectrogram. c will only be equal to frana(F,f)
        if the spectrogram is already consistent (i.e. already in the range space of F*).
        This is possible only for 'griflim' and 'fgriflim' methods.
     
        Generally, if the absolute value of the frame coefficients has not been
        modified, the iterative algorithm will converge slowly to the correct
        result. If the coefficients have been modified, the algorithm is not
        guaranteed to converge at all.
     
        FRSYNABS takes the following parameters at the end of the line of input
        arguments.
     
        Initial phase guess:
     
          'input'      Choose the starting phase as the phase of the input
                       s. This is the default
     
          'zero'       Choose a starting phase of zero.
     
          'rand'       Choose a random starting phase.
     
        The Griffin-Lim algorithm related parameters:
     
          'griflim'    Use the Griffin-Lim iterative method. This is the
                       default.
     
          'fgriflim'   Use the Fast Griffin-Lim iterative method.
     
     
          'Fd',Fd      A canonical dual frame object or an anonymous function
                       acting as the synthesis operator of the canonical dual frame.
                       If not provided, the function attempts to create one using
                       Fd=framedual(F).
     
          'alpha',a    Parameter of the Fast Griffin-Lim algorithm. It is
                       ignored if not used together with 'fgriflim' flag.
     
        The BFGS method related paramaters:
     
          'bfgs'       Use the limited-memory Broyden Fletcher Goldfarb
                       Shanno (BFGS) method.
     
          'p',p        Parameter for the compressed version of the obj. function
                       in the l-BFGS method. It is ignored if not used together
                       with 'bfgs' flag.
     
        Other:
     
          'tol',t      Stop if relative residual error is less than the
                       specified tolerance.
     
          'maxit',n    Do at most n iterations.
     
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     
          'printstep',p  If 'print' is specified, then print every p'th
                         iteration. Default value is p=10;
     
        The BFGS method makes use of the minFunc software. To use the BFGS method,
        please install the minFunc software from:
        http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html.
     
     
     
        References:
          D. Griffin and J. Lim. Signal estimation from modified short-time
          Fourier transform. IEEE Trans. Acoust. Speech Signal Process.,
          32(2):236--243, 1984.
          
          N. Perraudin, P. Balazs, and P. L. Soendergaard. A fast Griffin-Lim
          algorithm. In Applications of Signal Processing to Audio and Acoustics
          (WASPAA), 2013 IEEE Workshop on, pages 1--4, Oct 2013.
          
          R. Decorsiere, P. Soendergaard, E. MacDonald, and T. Dau. Inversion of
          auditory spectrograms, traditional spectrograms, and other envelope
          representations. Audio, Speech, and Language Processing, IEEE/ACM
          Transactions on, 23(1):46--56, Jan 2015.
          
     *Url*: <http://ltfat.github.io/doc/frames/frsynabs.html>

     See also: frana, frsyn, demo_frsynabs, demo_phaseret.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRSYNABS  Reconstruction from magnitude of coefficients
   Usage:  f=frsynabs...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2744
 -- Function: frsyniter
     FRSYNITER  Iterative synthesis
        Usage:  f=frsyniter(F,c);
                f=frsyniter(F,c,Ls);
                [f,relres,iter]=frsyniter(F,c,...);
     
        Input parameters:
              F       : Frame
              c       : Array of coefficients.
              Ls      : length of signal.
        Output parameters:
              f       : Signal.
              relres  : Vector of residuals.
              iter    : Number of iterations done.
     
        f=FRSYNITER(F,c) iteratively inverts the analysis operator of F, so
        FRSYNITER always performs the inverse operation of FRANA, even
        when a perfect reconstruction is not possible by using FRSYN.
     
        [f,relres,iter]=FRSYNITER(...) additionally returns the relative
        residuals in a vector relres and the number of iteration steps iter.
     
        *Note:* If it is possible to explicitly calculate the canonical dual
        frame then this is usually a much faster method than invoking
        FRSYNITER.
     
        FRSYNITER 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 (1e-5 for single precision)
     
          'maxit',n    Do at most n iterations.
     
          'cg'         Solve the problem using the Conjugate Gradient
                       algorithm. This is the default.
     
          'pcg'        Solve the problem using the Preconditioned Conjugate Gradient
                       algorithm. Please note that preconditioning is not supported
                       for all frame types.               
     
          'print'      Display the progress.
     
          'quiet'      Don't print anything, this is the default.
     
        Algorithms
        ----------
     
        The function uses the (Preconditioned) Conjugate Gradient algorithm
        to solve the following problem:
     
             FF*f=Fc
     
        The preconditioning alters the equations such that
     
             inv(M)FF*f=inv(M)Fc
     
        Examples
        --------
     
        The following example shows how to rectruct a signal without ever
        using the dual frame:
     
           F=frame('dgtreal','gauss',10,20);
           c=frana(F,bat);
           [r,relres]=frsyniter(F,c,'tol',1e-14);
           norm(bat-r)/norm(bat)
           semilogy(relres);
           title('Conversion rate of the CG algorithm');
           xlabel('No. of iterations');
           ylabel('Relative residual');
     
     *Url*: <http://ltfat.github.io/doc/frames/frsyniter.html>

     See also: frame, frana, frsyn, franaiter.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRSYNITER  Iterative synthesis
   Usage:  f=frsyniter(F,c);
           f=frsy...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1338
 -- Function: frsynmatrix
     FRSYNMATRIX  Frame synthesis operator matrix
        Usage: G=frsynmatrix(F,L);
     
        G=FRSYNMATRIX(F,L) returns the matrix representation G of the frame
        synthesis operator for a frame F of length L. The frame object F*
        must have been created using FRAME.
     
        The frame synthesis operator matrix contains all the frame atoms as
        column vectors. It has dimensions L xNcoef, where Ncoef is the
        number of coefficients. The number of coefficients can be found as
        Ncoef=frameclength(L). This means that the frame matrix is usually
        *very* large, and this routine should only be used for small values of
        L.
     
        The action of the frame analysis operator FRANA is equal to
        multiplication with the Hermitean transpose of the frame synthesis
        matrix. Consider the following simple example:
     
          L=200;
          F=frame('dgt','gauss',10,20);
          G=frsynmatrix(F,L);
          testsig = randn(L,1);
          res = frana(F,testsig)-G'*testsig;
          norm(res)
          % Show the matrix (real and imaginary parts)
          figure(1); imagesc(real(G));
          figure(2); imagesc(imag(G));
     
     *Url*: <http://ltfat.github.io/doc/frames/frsynmatrix.html>

     See also: frame, frana, frsyn.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
FRSYNMATRIX  Frame synthesis operator matrix
   Usage: G=frsynmatrix(F,L);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1674
 -- Function: fusionframe
     FUSIONFRAME  Construct a new fusion frame
        Usage: [F,L] = fusionframe(frametypes)
               [F,L] = fusionframe(frametypes, 'weights',weights)
               [F,L] = fusionframe(frametypes, 'ftype',params)
     
        F=FUSIONFRAME(ftype,...) constructs a new fusion frame object F of type
        ftype.
     
        Input parameters:
              frametypes     : Cell array with the desired frame types. For
                               supported frames, see below.
     
        Output parameters:
              F              : fusion frame structure
              L              : common frame length
     
        FUSIONFRAME facilitates the construction of fusion frames by allowing
        for their programmatic instantiation via the frame type of the local frames. 
        Further specification of the frames is optionally ppossible. For a
        list of supported frames as well as their defaults, see ARG_FUSIONFRAME. 
        Currently, only one set of optional parameters per fusion frame type is
        possible.
        The common frame length is calculated as the lowest common multiple of
        the frame lengths of the local frames.
     
        Optional parameters:
          'weights',weights     the fusion frame weights; per default set to one
     
          'frametype',ftype     further parameters for one or more specific
                                local frames
     
     
        Examples:
        ---------
     
        [F, L] = fusionframe({'dgt', 'fwt'}, 'dgt',{'gauss', 20, 30});
     
     
     *Url*: <http://ltfat.github.io/doc/frames/fusionframe.html>

     See also: frame.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FUSIONFRAME  Construct a new fusion frame
   Usage: [F,L] = fusionframe(frame...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2026
 -- Function: plotframe
     PLOTFRAME  Plot frame coefficients
        Usage: plotframe(F,c,…);
               C = plotframe(...);
     
        PLOTFRAME(F,c) plots the frame coefficients c using the plot
        command associated to the frame F.
     
        C=PLOTFRAME(...) for frames with time-frequency plots returns the
        processed image data used in the plotting. The function produces an
        error for frames which does not have a time-frequency plot.
     
        PLOTFRAME(F,c,...) passes any additional parameters to the native
        plot routine. Please see the help on the specific plot routine for a
        complete description. 
     
        The following common set of parameters are supported by all plotting
        routines:
     
          'dynrange',r
                   Limit the dynamical range to r. The default value of []
                   means to not limit the dynamical range.
     
          'db'     Apply 20*log_{10} to the coefficients. This makes 
                   it possible to see very weak phenomena, but it might show 
                   too much noise. A logarithmic scale is more adapted to 
                   perception of sound. This is the default.
     
          'dbsq'   Apply 10*log_{10} to the coefficients. Same as the
                   'db' option, but assume that the input is already squared.  
     
          'lin'    Show the coefficients on a linear scale. This will
                   display the raw input without any modifications. Only works for
                   real-valued input.
     
          'linsq'  Show the square of the coefficients on a linear scale.
     
          'linabs'  Show the absolute value of the coefficients on a linear scale.
     
          'clim',clim
                   Only show values in between clim(1) and clim(2). This
                   is usually done by adjusting the colormap. See the help on imagesc.
     
     *Url*: <http://ltfat.github.io/doc/frames/plotframe.html>

     See also: frame, frana.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
PLOTFRAME  Plot frame coefficients
   Usage: plotframe(F,c,…);
          C ...





