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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 221
 -- Function: COPYRIGHT
      Copyright (c) 2007 Thomas Blumensath
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/COPYRIGHT.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Copyright (c) 2007 Thomas Blumensath
 The University of Edinburgh
 Email: th...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
README


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4414
 -- Function: README
     
     
      __________________sparsify Version 0.5__________________
     
     
      __________________sparsify Version 0.4__________________
     
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.4
      Created: January 2009
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     
     
      __________________INSTALLATION__________________
     
      1) Copy the folder sparsify wherever you like. 
      2) Include the folder sparsify and all sub-folders in the Matlab search path.
     
      __________________OVERVIEW__________________
     
      sparsify is a set of Matlab m files implementing a range of different algorithms 
      to calculate sparse signal approximations. See ALGORITHMS below for a list of 
      available algorithms.
     
      __________________COMPATIBILITY__________________
     
      sparsify was tested with Matlab 7.2 and 7.4.
      sparsify does not require any additional toolboxes.
     
      All functions are designed to work with different input formats.
      The specific formatting instructions can be found in function_format.m and
      object_format.m
     
      The function format is compatible to the l1-magic toolbox [1] and with the GPSR software [4].
      The object format is compatible with the l1_ls.m algorithm [3].
      Unfortunately, SparseLab [5] uses a different function format, however, this 
      can easily be converted into the format required for sparsify using: 
      D  =@(z) P(1, m, n, z, I, dim)
      and
      Dt =@(z) P(2, m, n, z, I, dim)
      where P is the function used in SparseLab. D and Dt are then the functions
      required for sparsify. See function_format.m for more information.
     
      
      __________________STRUCTURE__________________
     
      sparsify contains four sub-folders with the following contents:
      GreedLab   : A range of greedy algorithms (see ALGORITHMS FOR DETAIL)
      HardLab    : A range of iterative hard-thresholding algorithms
      Examples   : Example code demonstrating the use of the algorithms
      TestMethod : A function to test the available algorithms
     
     
      The folder GreedLab contains:
     
      greed_omp.m
      greed_ols.m
      greed_mp.m
      greed_gp.m
      greed_nomp.m
      greed_nomppgc.m
      nonlin_gg.m
      The subfolder OMP_algos containing:
      	greed_omp_qr.m
      	greed_omp_chol.m
      	greed_omp_cg.m
      	greed_omp_cgp.m
      	greed_omp_pinv.m
      	greed_omp_linsolve.m
      
      The folder HardLab contains:
     
      hard_l0_reg
      hard_lo_Mterm
      
      The folder Examples contains:
     
      Example_object,m
      Example_function.m
      Example_matrix.m
      MyOp_witharg.m
      MyOpTranspose_witharg.m
      The subfolder @MyObjectName containing:
      	mtimes.m
      	MyObjectName.m
      	ctranspose.m
     
      The folder TestMethod contains:
     
      Testsparsify.m
     
      The folder Papers contains:
     
      
     
      __________________ALGORITHMS__________________
     
      For more information on each algorithm type "help ALGORITHMNAME.m"
     
      greed_omp.m	Orthogonal matching Pursuit algorithm. Different implementations are 
     		accessible through greed_omp.m. These are also available directly:
        greed_omp_qr.m 		OMP using QR factorisation (Fastest algorithm but 
     				requires most storage.)
      	greed_omp_chol.m	OMP using Cholesky factorisation (Slower than QR 
      				based method but less storage required. Useful up 
     				to around 10 000 non-zero coefficients)
      	greed_omp_cg.m 		OMP using full conjugate gradient solver in each
     				iteration (Only option if everything else fails. But 
     				can be slow.)
      	greed_omp_cgp.m		OMP using Conjugate Gradient Pursuit algorithm [1] 
     				(Similar to QR based method)
      	greed_omp_pinv.m	OMP using pinv command (NOT RECOMMENDED, for 
     				reference only.)	
      	greed_omp_linsolve.m	OMP using linsolve command (NOT RECOMMENDED, for 
     				reference only.)
     *Url*: <http://ltfat.github.io/doc/thirdparty/sparsify/README.html>


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




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4172
 -- Function: greed_gp
      greed_gp: Gradient Pursuit algorithm from [1]
     
      Usage
      [s, err_mse, iter_time]=greed_gp(x,P,m,'option_name','option_value')
     
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                               Also requires specification of P_trans option.
                            3) An object handle (type "help object_format" for 
                               more information)
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        P_trans         FUNCTION_HANDLE (SEE BELOW)                 
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
        GradSteps       'AUTO' OR INTEGER                           'auto'
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
        GradSteps: Number of gradient optimisation steps per iteration.
                   'auto' uses inner products to decide if more gradient steps 
                   are required. 
     
     
      Outputs
         s              Solution vector 
         err_mse        Vector containing mse of approximation error for each 
                        iteration
         iter_time      Vector containing times for each iteration
     
     
      Description
        greed_gp performs a greedy signal decomposition. 
        In each iteration a new element is selected depending on the inner
        product between the current residual and columns in P.
        Gradient optimisation is used to update all selected non-zero elements.
        
        THIS ALGORITHM IS AN ALTERNATIVE TO OMP IF OMP IS NOT FEASIBLE DUE TO
        COMPUTATION TIME OR STORAGE REQUIREMENTS!
        
      References
        [1] T. Blumensath and M.E. Davies, "Gradient Pursuits", submitted, 2007
     
      See Also
        greed_omp, greed_ols, greed_mp, greed_nomp, greed_pcgp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.1
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_gp.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
 greed_gp: Gradient Pursuit algorithm from [1]



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4036
 -- Function: greed_mp
      greed_mp: Matching Pursuit algorithm
     
      Usage
      [s, err_mse, iter_time]=greed_mp(x,P,m,'option_name','option_value')
     
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                               Also requires specification of P_trans option.
                            3) An object handle (type "help object_format" for 
                               more information)
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        P_trans         FUNCTION_HANDLE (SEE BELOW)                 
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
     
      Outputs
         s              Solution vector 
         err_mse        Vector containing mse of approximation error for each 
                        iteration
         iter_time      Vector containing computation times for each iteration
     
     
      Description
        greed_mp performs a greedy signal decomposition. 
        In each iteration a new element is selected depending on the inner
        product between the current residual and columns in P.
        The single non-zero element associated with the largest inner product 
        is then updated by adding the associated inner product.
     
        THIS IS NOT THE FASTEST IMPLEMENTATION POSSIBLE! WE DO CALCULATE ALL
        INNER PRODUCTS IN EACH ITERATION. FASTER IMPLEMENTATIONS WOULD USE
        LOCAL UPDATES OF INNER PRODUCTS. USE [1] FOR A FASTER ALTERNATIVE!
        
        [1] Matching Pursuit Toolkit http://mptk.gforge.inria.fr/
     
      See Also
        greed_qp, greed_nomp, greed_omp, greed_ols, greed_pcgp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.1
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_mp.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
 greed_mp: Matching Pursuit algorithm



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5053
 -- Function: greed_nomp
      greed_nomp: Nearly Orthogonal Matching Pursuit or Approximate Conjugate 
                  Gradient Pursuit algorithm
     
      Usage
        [s, err_mse, iter_time]=greed_nomp(x,P,m,'option_name','option_value')
     
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                               Also requires specification of P_trans option.
                            3) An object handle (type "help object_format" for 
                               more information)
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        P_trans         FUNCTION_HANDLE (SEE BELOW)                 
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
        GradSteps       'AUTO' OR INTEGER                           'auto'
        wf              WEAKNES FACTOR [1 0)                        1
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum number of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
        GradSteps: Number of gradient optimisation steps per iteration.
                   'auto' uses inner products to decide if more gradient steps 
                   are required. 
     
        wf: weakness factor alpha (see [2] and [3]). Algorithm will select all 
            elements fror which P_TRANS RESIDUAL >= alpha max(|P_trans residual|)
     
     
      Outputs
         s              Solution vector 
         err_mse        Vector containing mse of approximation error for each 
                        iteration
         iter_time      Vector containing computation times for each iteration
     
     
      Description
        greed_nomp performs a greedy signal decomposition. 
        In each iteration a new element is selected depending on the inner
        product between the current residual and columns in P.
        A directional update is used that is conjuagte to the previously used
        direction.
        
        THIS ALGORITHM IS AN ALTERNATIVE TO OMP IF OMP IS NOT FEASIBLE DUE TO
        COMPUTATION TIME OR STORAGE REQUIREMENTS! IT IS IN GENERAL BETTER THAN
        greed_gp
        
      References
        [1] T. Blumensath and M.E. Davies, "Gradient Pursuits", to appear in 
            IEEE Transactions on Signal Processing
        [2] M.E. Davies and T. Blumensath; "Faster & Greedier: algorithms for 
            sparse reconstruction of large datasets ", invited paper to the 
            third IEEE International Symposium on Communications, Control, and 
            Signal Processing, St Julians, Malta, March 2008.
        [3] T. Blumensath, M. E. Davies; "Fast greedy algorithms for large
            sparse inverse problems", submitted to EUSIPCO, 2008
      See Also
        greed_omp, greed_ols, greed_mp, greed_gp, greed_pcgp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.3
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_nomp.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 greed_nomp: Nearly Orthogonal Matching Pursuit or Approximate Conjugate 
   ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4299
 -- Function: greed_ols
      greed_ols: Orthogonal Least Squares algorithm
     
      Usage
        [s, err_mse, iter_time]=greed_ols(x,P,m,'option_name','option_value');
     
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                               Also requires specification of P_trans option.
                            3) An object handle (type "help object_format" for 
                               more information)
                            NOTE: The algorithm works on matrices, so P will be
                            converted to matrix. This means that the algorithm
                            only works for small problems.
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
     
      Outputs
         s              Solution vector 
         err_mse        Vector containing mse of approximation error for each 
                        iteration
         iter_time      Vector containing times for each iteration
     
     
      Description
        greed_ols performs a greedy signal decomposition. 
        In each iteration a new element is selected that will reduce the 
        residual error the most in the next step. This is different from OMP.
        See [1] and [2] for details.
        The non-zero elements of s are approximated by orthogonally projecting 
        x onto the selected elements in each iteration.
        The algorithm uses QR factorisation.
        
      References
        [1] S. Chen and S. A. Billings Modelling and analysis of non-linear time series. 
     	International Journal of Control, 50 pp. 2151-2171, 1989
        [2] T. Blumensath, M. E. Davies; "On the Difference Between Orthogonal Matching Pursuit and %       Orthogonal Least Squares", manuscript 2007
     
      See Also
        greed_omp, greed_mp, greed_gp, greed_nomp, greed_pcgp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.1
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_ols.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
 greed_ols: Orthogonal Least Squares algorithm



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6186
 -- Function: greed_omp
      greed_omp: Orthogonal Matching Pursuit using a range of implementations
     
      Usage
     	[s, cost, iter_time ]=greed_omp(x,P,m,'option_name','option_value')
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                            3) An object handle (type "help object_format" for 
                               more information)
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        solver          AUTO, QR, CHOL, CGP, CG, PINV, LINSOLVE     auto
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        P_trans         FUNCTION_HANDLE (SEE BELOW)                 
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
     
     
      Explanation of possible option
     
        solver: different implementations of OMP are available. The fastest
                method is the QR algorithm, followed by the Cholesky based 
                approach. The QR based algorithm requires storage of an nxM
                matrix and an MxM triangular matrix, for long signals or 
                large M, this can be too much. The Cholesky based approach
                requires storage of an upper triangular matrix of size MxM,
                however, it also requires repeated solutions of inverse systems
                involving this matrix, which for large M can become slow.
                Available options are:
                    auto        -   selects from qr, chol or cg depending on
                                    problem size
                    qr          -   uses QR based method
                    chol        -   Uses Cholesky based method
                    cgp         -   Uses Conjugate Gradient Pursuit 
                                    implementation (See [1] for details)
                    cg          -   Solves the inverse problem in each
                                    iteration using Conjugate Gradient
                                    algorithm. This is the only viable option
                                    to solve OMP for very large problems. 
                    pinv        -   Uses matlab PINV command to solve inverse
                                    problem in OMP iteration. (For
                                    reference only.)
                    linsolve    -   Uses matlab LINSOLVE command to solve 
                                    inverse problem in OMP iteration. (For
                                    reference only.)
     
        stopCrit: Stopping criterion for the algorithm.
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum number of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
     
      Outputs
         s              Solution vector 
         err_norm       Vector containing norm of approximation error for each 
                        iteration
         iter_time      Vector containing computation times for each iteration
     
     
      Description
        greed_omp performs a greedy signal decomposition. 
        In each iteration a new element is selected depending on the inner
        product between the current residual and columns in P.
        The non-zero elements of s are approximated by orthogonally projecting 
        x onto the selected elements in each iteration.
        Different algorithms are possible to solve this projection. 
        greed_omp has access to the following implementations (see options):
        1) QR decomposition based algorithm.
        2) Cholesky factorisation based algorithm.
        3) Single Step Conjugate Gradient implementation as described in [1].
        4) Full Conjugate Gradient solver in each iteration.
        4) Pseudo Inverse solution in each iteration. (Not recommended!)
        5) Use of matlab linsolve in each iteration. (Not recommended!)
     
      References
        [1] T. Blumensath and M.E. Davies, "Gradient Pursuits", submitted, 2007
     
      See Also
        greed_mp, greed_gp, greed_nomp, greed_omp, greed_pcgp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.1
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_omp.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
 greed_omp: Orthogonal Matching Pursuit using a range of implementations



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4353
 -- Function: greed_pcgp
      greed_pcgp: Nearly Orthogonal Matching Pursuit using a partial conjugate
                    gradient solver (Partial Conjugate Gradient Pursuit)
     
      Usage
        [s, err_mse, iter_time]=greed_pcgp(x,P,m,'option_name','option_value')
     
     
      Input
        Mandatory:
                    x   Observation vector to be decomposed
                    P   Either:
                            1) An nxm matrix (n must be dimension of x)
                            2) A function handle (type "help function_format" 
                               for more information)
                               Also requires specification of P_trans option.
                            3) An object handle (type "help object_format" for 
                               more information)
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, MSE, MSE_CHANGE                    M
        stopTol         NUMBER (SEE BELOW)                          n/4
        P_trans         FUNCTION_HANDLE (SEE BELOW)                 
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
        GradSteps       'AUTO' OR INTEGER                           'auto'
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    mse         -   Stops when mean squared error of residual 
                                    is below stopTol value.
                    mse_change  -   Stops when the change in the mean squared 
                                    error falls below stopTol value.
     
        stopTol: Value for stopping criterion.
     
        P_trans: If P is a function handle, then P_trans has to be specified and 
                 must be a function handle. 
     
        maxIter: Maximum number of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
        GradSteps: Number of gradient optimisation steps per iteration.
                   'auto' uses inner products to decide if more gradient steps 
                   are required. 
     
     
      Outputs
         s              Solution vector 
         err_mse        Vector containing mse of approximation error for each 
                        iteration
         iter_time      Vector containing computation times for each iteration
     
     
      Description
        greed_pcgp performs a greedy signal decomposition. 
        In each iteration a new element is selected depending on the inner
        product between the current residual and columns in P.
        A conjugate gradient solver is used until a new element is selected,
        after which a new conjuagte gradient solver is started. (See [1])
        
        THIS ALGORITHM IS AN ALTERNATIVE TO OMP IF OMP IS NOT FEASIBLE DUE TO
        COMPUTATION TIME OR STORAGE REQUIREMENTS! 
        
      References
        [1] T. Blumensath and M.E. Davies, "Gradient Pursuits", submitted, 2007
      See Also
        greed_omp, greed_ols, greed_mp, greed_gp
     
      Copyright (c) 2007 Thomas Blumensath
     
      The University of Edinburgh
      Email: thomas.blumensath@ed.ac.uk
      Comments and bug reports welcome
     
      This file is part of sparsity Version 0.1
      Created: April 2007
     
      Part of this toolbox was developed with the support of EPSRC Grant
      D000246/1
     
      Please read COPYRIGHT.m for terms and conditions.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/greed_pcgp.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 greed_pcgp: Nearly Orthogonal Matching Pursuit using a partial conjugate
   ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4320
 -- Function: nonlin_gg
      nonlin_gg: Nonlinear sparse approximation by greedy gradient search.
     
     
      Usage
      [s, err_cost, iter_time]=nonlin_gg(x,P,m,'option_name','option_value')
     
     
      Input
        Mandantory:
                    x   Observation vector to be decomposed
                    F   Function mapping from the sparse coeficient domain to
                        the observation domain.
                    C   Function handle to cost function to be optimised
                    m   length of s 
     
        Possible additional options:
        (specify as many as you want using 'option_name','option_value' pairs)
        See below for explanation of options:
     __________________________________________________________________________
        option_name         AVAILABLE OPTION_VALUES                 default
     --------------------------------------------------------------------------
        stopCrit        M, CORR, COST, COST_CHANGE                  M
        stopTol         NUMBER (SEE BELOW)                          n/4
        maxIter         POSITIVE INTEGER (SEE BELOW)                n
        verbose         TRUE, FALSE                                 false
        start_val       VECTOR OF LENGTH M                          zeros
        weights         VECTOR OF LENGTH M CONTAINING WEIGHTS       ones
                        TO BIASE ATOM SELECTION                    
        grad_pert       PERTUBATION SIZE TO NUMERICALLY EVALUATE    1e-6
                        GRADIENT                                   
        step_size       STEP SIZE FOR GRADIENT OPTIMISATION STEP    0.1
        grad_stop       CHANGE IN THE NORM OF THE GRADIENT BELOW    1e-3
                        WHICH GRADIENT OPTIMISATION STOPS          
        max_grad        MAXIMUM NUMBER OF GRADIENT STEPS            1000
        grad            FUNCTION HANDLE TO GRADIENT OF COST        
                        FUNCTION TO BE OPTIMISED                    
        optimiser       FUNCTION HANDLE TO A FUNCTION THAT         
                        OPTIMISES F FOR GIVEN INITIAL VALUE AND    
                        GIVEN SUBSET OF COEFFICIENTS               
        PlotFunc        FUNCTION HANDLE TO A FUNCTION THAT         
                        PLOTS ESTIMATE OF SIGNAL GIVEN SPARSE      
                        COEFFICIENT ESTIMATE                       
                                                                    
     
        Available stopping criteria :
                    M           -   Extracts exactly M = stopTol elements.
                    corr        -   Stops when maximum correlation between
                                    residual and atoms is below stopTol value.
                    cost        -   Stops when cost C is below stopTol value.
                    cost_change -   Stops when the change cost C falles below
                                    stopTol value.
     
        stopTol: Value for stoping criterion.
     
        maxIter: Maximum of allowed iterations.
     
        verbose: Logical value to allow algorithm progress to be displayed.
     
        start_val: Allows algorithms to start from partial solution.
     
        optimiser: Allows the specification of a function OPT(s,x,INDEX). 
                   OPT msut return the full coefficient vector s after 
                   optimisation of the cost function C over a given subset of
                   coefficients in s indexed by INDEX.
     
     
      Outputs
     	 s              Solution vector 
         err_cost       Vector containing cost of approximation error for each 
                        iteration
         iter_time      Vector containing times for each iteration
     
     
      Description
        Algorithm selects greedily new elements in each iteration based on the
        gradient of the cost function to be minimised with respect to the
        coefficients. If the exact gradient is not specified, the gradienbt is
        approximated using diference between cost at s and at s+DELTA. Once a
        new element has been selected, gradient optimisation is used to
        minimise the cost function based on the selected elements.
     *Url*:
     <http://ltfat.github.io/doc/thirdparty/sparsify/nonlin_gg.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
 nonlin_gg: Nonlinear sparse approximation by greedy gradient search.





