# Created by Octave 3.8.2, Sat Sep 27 14:05:27 2014 UTC <root@rama>
# name: cache
# type: cell
# rows: 3
# columns: 26
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
Contents


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

  Peter L. Soendergaard, 2012 - 2014.

  Creation of a frame object
    FRAME             - Construct a new frame
    FRAMEPAIR         - Construct a pair of frames
    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
    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

  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

  Non-linear analysis and synthesis
    FRANALASSO        - LASSO threshholding using Landweber iterations.
    FRANAGROUPLASSO   - Group LASSO threshholding.
    FRSYNABS          - Frame synthesis from magnitude of coefficients

  For help, bug reports, suggestions etc. please send email to
  ltfat-help@lists.sourceforge.net

   Url: http://ltfat.sourceforge.net/doc/frames/Contents.php



# 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: 5168
 -- 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('dftreal') constructs a normalized FFTREAL basis for
        real-valued signals of even length only. The basis is normalized the
        DFT to ensure that is it orthonormal.

        Special / general frames
        ------------------------

        FRAME('gen',g) constructs an general frame with analysis matrix g.
        The frame atoms must be stored as column vectors in the matrices.

        FRAME('identity') constructs the canonical orthornormal basis, meaning
        that all operators return their input as output, so it is the dummy
        operation.

        FRAME('randn',red,seed) constructs a frame with redundancy red*
        consisting of random noise generated by randn. The optional parameter
        seed specifies the initial seed for the noise generation. All frame
        vectors are normalized to have unit energy / l^2-norm.

        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.

        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);

     *Url*: <http://ltfat.sourceforge.net/doc/frames/frame.php>

     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: 905
 -- Function: frameaccel
     FRAMEACCEL  Precompute structures
        Usage: F=frameaccel(F,L);

        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, is will be a benefit.

        Notice that you need to input the signal length Ls, so this routines
        is only 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.sourceforge.net/doc/frames/frameaccel.php>

     See also: frame, frana, framelength, framelengthcoef.




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



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


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

        FRAMEBOUNDS(F) calculates the ratio B/A of the frame bounds of the
        frame given by F.

        FRAMEBOUNDS(F,Ls) additionally specifies a signal length for which
        the frame should work.

        [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 is less than the
                       specified tolerance. Default is 1e-9

          'maxit',n    Do at most n iterations.

          '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 is 2.

          'print'      Display the progress.

          'quiet'      Don't print anything, this is the default.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/framebounds.php>

     See also: frame, framered.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 465
 -- Function: framecoef2native
     FRAMECOEF2NATIVE  Convert coefficients to native format
        Usage: cout=framecoef2native(F,cin);

        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.sourceforge.net/doc/frames/framecoef2native.php>

     See also: frame, framenative2coef, framecoef2tf.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 801
 -- Function: framecoef2tf
     FRAMECOEF2TF  Convert coefficients to time-frequency plane
        Usage: cout=framecoef2tf(F,cin);

        FRAMECOEF2TF(F,coef) converts the frame coefficients coef 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 frame types support this coefficient layout. The supported frame
        types are: 'dgt', 'dgtreal', 'dwilt', 'wmdct' and
        'ufilterbank'.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/framecoef2tf.php>

     See also: frame, frametf2coef, framecoef2native.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 433
 -- 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.sourceforge.net/doc/frames/framediag.php>

     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,L)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 711
 -- Function: framedual
     FRAMEDUAL  Construct the canonical dual frame
        Usage: F=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.sourceforge.net/doc/frames/framedual.php>

     See also: frame, framepair, frametight.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 516
 -- Function: framegram
     FRAMEGRAM  Easy visualization of energy in frame space
        Usage: framegram(F,x);

        FRAMEGRAM(F,x) plots the energy of the 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.sourceforge.net/doc/frames/framegram.php>

     See also: plotframe.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRAMEGRAM  Easy visualization of energy in frame space
   Usage: framegram(F,x);



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 534
 -- 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.sourceforge.net/doc/frames/framelength.php>

     See also: frame, framelengthcoef.




# 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: 448
 -- 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.sourceforge.net/doc/frames/framelengthcoef.php>

     See also: frame, framelength.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 401
 -- Function: framenative2coef
     FRAMENATIVE2COEF  Convert coefficient from native format
        Usage: cout=framenative2coef(F,cin);

        FRAMENATIVE2COEF(F,coef) convert frame coefficients from the native
        format of the transform into the common column format.

     *Url*:
     <http://ltfat.sourceforge.net/doc/frames/framenative2coef.php>

     See also: frame, framecoef2native.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1263
 -- Function: framepair
     FRAMEPAIR  Construct a new frame
        Usage: F=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.sourceforge.net/doc/frames/framepair.php>

     See also: frame, framedual, frametight.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 775
 -- 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.sourceforge.net/doc/frames/framered.php>

     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: 10
framesinit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 95
 -- Function: framesinit
     *Url*: <http://ltfat.sourceforge.net/doc/frames/framesinit.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
   *Url*: <http://ltfat.sourceforge.net/doc/frames/framesinit.php>



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 390
 -- Function: frametf2coef
     FRAMETF2COEF  Convert coefficients from TF-plane format
        Usage: cout=frametf2coef(F,cin);

        FRAMETF2COEF(F,coef) convert frame coefficients from the
        time-frequency plane layout into the common column format.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/frametf2coef.php>

     See also: frame, framecoef2tf, framecoef2native.




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



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


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

        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.sourceforge.net/doc/frames/frametight.php>

     See also: frame, framepair, framedual.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1289
 -- 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.sourceforge.net/doc/frames/frana.php>

     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: 15
franagrouplasso


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3829
 -- Function: franagrouplasso
     FRANAGROUPLASSO  Group LASSO regression in the TF-domain
        Usage: [tc,xrec] = franagrouplasso(F,x,group,lambda,C,maxit,tol)

        Input parameters:
            F        : Frame definition
            x        : Input signal
            lambda   : Regularization parameter, controls sparsity of the
                       solution
        Output parameters:
           tc        : Thresholded coefficients
           relres    : Vector of residuals.
           iter      : Number of iterations done.
           xrec      : Reconstructed signal

        FRANAGROUPLASSO(F,x) 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.

        [tc,relres,iter] = FRANAGROUPLASSO(...) returns the residuals relres in
        a vector and the number of iteration steps done, maxit.

        [tc,relres,iter,xrec] = FRANAGROUPLASSO(...) returns the reconstructed
        signal from the coefficients, xrec. 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 :

          xrec = 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.sourceforge.net/doc/frames/franagrouplasso.php>

     See also: franalasso, framebounds.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
FRANAGROUPLASSO  Group LASSO regression in the TF-domain
   Usage: [tc,xrec] = f



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2316
 -- 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.sourceforge.net/doc/frames/franaiter.php>

     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,relres,



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3183
 -- Function: franalasso
     FRANALASSO  Frame LASSO regression
        Usage: [tc,xrec] = franalasso(F,f,lambda,C,tol,maxit)

        Input parameters:
            F        : Frame definition
            f        : Input signal
            lambda   : Regularization parameter, controls sparsity of the solution
        Output parameters:
            tc       : Thresholded coefficients
            relres   : Vector of residuals.
            iter     : Number of iterations done.
            frec     : Reconstructed signal

        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.

        The solution is obtained via an iterative procedure, called Landweber
        iteration, involving iterative soft thresholdings.

        [tc,relres,iter] = FRANALASSO(...) return thes residuals relres in a vector
        and the number of iteration steps done, maxit.

        [tc,relres,iter,frec] = FRANALASSO(...) returns the reconstructed
        signal from the coefficients, frec. Note that this requires additional
        computations.

        The relationship between the output coefficients 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;

        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.


        References:
          I. Daubechies, M. Defrise, and C. De Mol. An iterative thresholding
          algorithm for linear inverse problems with a sparsity constraint.
          Communications in Pure and Applied Mathematics, 57:1413-1457, 2004.

          A. Beck and M. Teboulle. A fast iterative shrinkage-thresholding
          algorithm for linear inverse problems. SIAM J. Img. Sci., 2(1):183-202,
          Mar. 2009.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/franalasso.php>

     See also: frame, frsyn, framebounds, franagrouplasso.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 358
 -- 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.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/frsyn.php>

     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: 2490
 -- Function: frsynabs
     FRSYNABS  Reconstruction from magnitude of coefficients
        Usage:  f=frsynabs(F,s);
                f=frsynabs(F,s,Ls);
                [f,relres,iter]=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.

        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.

        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 coeffficients 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:

          '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.

          '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;


        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.

     *Url*: <http://ltfat.sourceforge.net/doc/frames/frsynabs.php>

     See also: dgt, idgt.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2181
 -- Function: frsyniter
     FRSYNITER  Iterative synthesis
        Usage:  f=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.

          '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=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.sourceforge.net/doc/frames/frsyniter.php>

     See also: frame, frana, frsyn, franaiter.




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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1175
 -- 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=framered(F)*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
        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)

     *Url*: <http://ltfat.sourceforge.net/doc/frames/frsynmatrix.php>

     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: 9
plotframe


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1717
 -- Function: plotframe
     PLOTFRAME  Plot frame coefficients
        Usage: plotframe(F,insig,...);

        PLOTFRAME(F,c) plots the frame coefficients c using the plot
        command associated to the frame F.

        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.sourceforge.net/doc/frames/plotframe.php>

     See also: frame, frana.




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





