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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6082
 LTFAT - Wavelets

   Zdenek Prusa, 2013 - 2023.

   If you use the wavelets module for a scientific work, please cite:

   Z. Průša, P. L. Soendergaard, and P. Rajmic. “Discrete Wavelet Transforms in the Large
   Time-Frequency Analysis Toolbox for MATLAB/GNU Octave.” ACM Trans. Math. Softw. 42, 4,
   Article 32, 2016. DOI: 10.1145/2839298
   
   Basic analysis/synthesis
      FWT               - Fast Wavelet Transform 
      IFWT              - Inverse Fast Wavelet Transform
      FWT2              - 2D Fast Wavelet Transform 
      IFWT2             - 2D Inverse Fast Wavelet Transform
      UFWT              - Undecimated Fast Wavelet Transform
      IUFWT             - Inverse Undecimated Fast Wavelet Transform 
      FWTLENGTH         - Length of Wavelet system to expand a signal
      FWTCLENGTH        - Lengths of the wavelet coefficient subbands

   Advanced analysis/synthesis
      WFBT              - Transform using general Wavelet Filter Bank Tree 
      IWFBT             - Inverse transform using general Wavelet Filter Bank Tree
      UWFBT             - Undecimated transform using general Wavelet Filter Bank Tree 
      IUWFBT            - Inverse Undecimated transform using general Wavelet Filter Bank Tree
      WPFBT             - Wavelet Packet Transform using general Wavelet Filter Bank Tree 
      IWPFBT            - Inverse Wavelet Packet Transform using general Wavelet Filter Bank Tree
      UWPFBT            - Undecimated Wavelet Packet Transform using general Wavelet Filter Bank Tree 
      IUWPFBT           - Inverse Undecimated Wavelet Packet Transform using general Wavelet Filter Bank Tree
      WPBEST            - Best Tree selection
      WFBTLENGTH        - Length of Wavelet filter bank system to expand a signal
      WFBTCLENGTH       - Lengths of Wavelet filter bank coefficient subbands
      WPFBTCLENGTH      - Lengths of Wavelet Packet transform coefficient subbands

   Dual-tree complex wavelet transform
      DTWFB             - Dual-Tree Wavelet Filter Bank
      IDTWFB            - Inverse Dual-Tree Wavelet Filter Bank
      DTWFBREAL         - Dual-Tree Wavelet Filter Bank for real-valued signals
      IDTWFBREAL        - Inverse Dual-Tree Wavelet Filter Bank for real-valued signals

   Wavelet Filterbank trees manipulation
      WFBTINIT          - Wavelet Filter Bank tree structure initialization
      DTWFBINIT         - Dual-Tree wavelet filter bank structure initialization
      WFBTPUT           - Puts node (basic filter bank) to the specific  tree coordinates
      WFBTREMOVE        - Removes node (basic filter bank) from the specific tree coordinates
      WFBT2FILTERBANK   - WFBT or FWT non-iterated filter bank using the multi-rate identity
      WPFBT2FILTERBANK  - WPFBT non-iterated filter bank using the multi-rate identity
      DTWFB2FILTERBANK  - DTWFB or DTWFBREAL non-iterated filter bank
      FWTINIT           - Basic Wavelet Filters structure initialization

   Frame properties of wavelet filter banks:
      WFBTBOUNDS        - Frame bounds of WFBT and FWT (or UWFBT and UFWT)
      WPFBTBOUNDS       - Frame bounds of WPFBT or UWPFBT
      DTWFBBOUNDS       - Frame bounds of DTWFB
  
   Plots
      PLOTWAVELETS      - Plot wavelet coefficients
      WFILTINFO         - Plot wavelet filters impulse and frequency responses and approximation of scaling and wavelet functions
      WFILTDTINFO       - Plot the same as WFILTINFO but for dual-tree wavelet transform

   Auxilary
      WAVFUN            - Approximate of the continuous scaling and wavelet functions
      WAVCELL2PACK      - Changes wavelet coefficient storing format
      WAVPACK2CELL      - Changes wavelet coefficient storing format back

   Wavelet Filters defined in the time-domain
      WFILT_ALGMBAND    - An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction
      WFILT_CMBAND      - M-Band cosine modulated wavelet filters
      WFILT_COIF        - Coiflets
      WFILT_DB          - DauBechies orthogonal filters (ortonormal base)
      WFILT_DDEN        - Double-DENsity dwt filters (tight frame)
      WFILT_DGRID       - Dense GRID framelets (tight frame, symmetric)
      WFILT_HDEN        - Higher DENsity dwt filters (tight frame, frame)  
      WFILT_LEMARIE       - Battle and Lemarie quadrature filters
      WFILT_MATLABWRAPPER - Wrapper of the wfilters function from the Matlab Wavelet Toolbox 
      WFILT_MBAND           - M-band filters
      WFILT_REMEZ           - Wavelet orthonogal filters based on the Remez Exchange algorithm
      WFILT_SYMDS           - SYMmetric wavelet Dyadic Siblings (frames)
      WFILT_SPLINE          - Biorthogonal spline wavelet filters
      WFILT_SYM             - Least asymmetric Daubechies wavelet filters
      WFILT_SYMDDEN         - Symmetric Double-DENsity dwt filters (tight frame)
      WFILT_SYMORTH         - Symmetric nearly-orthogonal and orthogonal nearly-symmetric wav. filters
      WFILT_SYMTIGHT        - Symmetric nearly shift-invariant tight frame wavelets
      WFILT_QSHIFTA         - First tree filters from WFILTDT_QSHIFT 
      WFILT_QSHIFTB         - Second tree filters from WFILTDT_QSHIFT 
      WFILT_ODDEVENA        - First tree filters from WFILTDT_ODDEVEN 
      WFILT_ODDEVENB        - Second tree filters from WFILTDT_ODDEVEN 
      WFILT_OPTSYMA         - First tree filters from WFILTDT_OPTSYM 
      WFILT_OPTSYMB         - Second tree filters from WFILTDT_OPTSYM 
      WFILT_DDENA           - First tree filters from WFILTDT_DDEN 
      WFILT_DDENB           - Second tree filters from WFILTDT_DDEN 

   Dual-Tree Filters
      WFILTDT_QSHIFT        - Kingsbury's quarter-shift filters
      WFILTDT_OPTSYM        - Optimizatized Symmetric Self-Hilbertian Filters
      WFILTDT_ODDEVEN       - Kingsbury's symmetric odd and even biorthogonal filters
      WFILTDT_DDEN          - Double-density dual-tree filters

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
 LTFAT - Wavelets



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 278
 -- Function: isoctave
     ISOCTAVE  True if the operating environment is octave
        Usage: t=isoctave();
     
        ISOCTAVE returns 1 if the operating environment is Octave, otherwise
        it returns 0 (Matlab)
     *Url*: <http://ltfat.github.io/doc/isoctave.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
ISOCTAVE  True if the operating environment is octave
   Usage: t=isoctave();



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4271
 -- Function: ltfatarghelper
     LTFATARGHELPER  Parse arguments for LTFAT
        Usage: [flags,varargout]  = ltfatarghelper(posdepnames,definput,arglist,callfun);
     
        Input parameters:
           posdepnames : Names of the position dependant parameters.
           definput    : Struct to define the allowed input
           arglist     : Commandline of the calling function (varargin)
           callfun     : Name of calling function (optional)
     
        Output parameters:
           flags       : Struct with information about flags.
           keyvals     : Struct with key / values.
           varargout   : The position dependant pars. properly initialized
     
        [flags,keyvals]=LTFATARGHELPER(posdepnames,definput,arglist) assists in
        parsing input parameters for a function in LTFAT. Parameters come in
        four categories:
       
         Position dependant parameters. These must not be strings. These are
          the first parameters passed to a function, and they are really just a
          short way of specifying key/value pairs. See below.
     
         Flags. These are single string appearing after the position dependant
          parameters.
     
         Key/value pairs. The key is always a string followed by the value,
          which can be anything.
     
         Expansions. These appear as flags, that expand into a pre-defined list
          of parameters.  This is a short-hand way of specifying standard sets of
          flags and key/value pairs.
     
        The parameters are parsed in order, so parameters appearing later in
        varargin will override previously set values.
     
        The following example for calling LTFATARGHELPER is taken from DGT:
       
          definput.keyvals.L=[];
          definput.flags.phase={'freqinv','timeinv'};
          [flags,kv]=ltfatarghelper({'L'},definput,varargin);
     
        The first line defines a key/value pair with the key 'L' having an
        initial value of [] (the empty matrix).
     
        The second line defines a group of flags by the name of phase.  The
        group phase contains the flags 'freqinv' and 'timeinv', which can
        both be specified on the command line by the user. The group-name
        phase is just for internal use, and does not appear to the user. The
        flag mentioned first in the list will be selected by default, and only
        one flag in a group can be selected at any time. A group can contain as
        many flags as desired.
       
        The third line is the actual call to LTFATARGHELPER which defines the
        output flags and kv.  The input {'L'} indicates that the value of
        the parameter 'L' can also be given as the very first value in
        varargin.
     
        The output struct kv contains the key/value pairs, so the value
        associated to 'L' is stored in kv.L.
     
        The output struct flags contains information about the flags choosen
        by the user. The value of flags.phase will be set to the selected flag
        in the group phase and additionally, the value of flags.do_timeinv
        will be 1 if 'timeinv' was selected and 0 otherwise, and similarly for
        'freqinv'. This allows for easy checking of selected flags.
     
        Advanced usage
        --------------
        
        Expansion import was introduced in order to allow sharing common
        flags and key/value pairs between functions. 
        
        The following example is taken from PLOTDGT and TFPLOT:
     
            definput.import={'ltfattranslate','tfplot'};
            [flags,kv,fs]=ltfatarghelper({'fs','dynrange'},definput,varargin);
     
        This code instructs LTFATARGHELPER to run functions 
        arg_ltfattranslate and arg_tfplot which define the flags and 
        the key/value pairs. The arg_ functions must have the following signature:
     
            function definput=arg_name(definput)
     
        Moreover, a special flag 'argimport' is used to pass the flags 
        and the key/value pairs from PLOTDGT to TFPLOT:
     
            coef=tfplot(...,'argimport',flags,kv);
        
     *Url*: <http://ltfat.github.io/doc/ltfatarghelper.html>

     See also: ltfatgetdefaults, ltfatsetdefaults.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LTFATARGHELPER  Parse arguments for LTFAT
   Usage: [flags,varargout]  = ltfa...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 324
 -- Function: ltfatbasepath
     LTFATBASEPATH  The base path of the LTFAT installation
        Usage: bp = ltfatbasepath;
     
        LTFATBASEPATH returns the top level directory in which the LTFAT
        files are installed.
     
     *Url*: <http://ltfat.github.io/doc/ltfatbasepath.html>

     See also: ltfatstart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LTFATBASEPATH  The base path of the LTFAT installation
   Usage: bp = ltfatba...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 387
 -- Function: ltfatgetdefaults
     LTFATGETDEFAULTS  Get default parameters of function
     
        LTFATGETDEFAULTS(fname) returns the default parameters
        of the function fname as a cell array.
     
        LTFATGETDEFAULTS('all') returns all the set defaults.
     
     *Url*: <http://ltfat.github.io/doc/ltfatgetdefaults.html>

     See also: ltfatsetdefaults, ltfatstart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
LTFATGETDEFAULTS  Get default parameters of function



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 521
 -- Function: ltfathelp
     LTFATHELP Help on the LTFAT toolbox
        Usage:  ltfathelp;
                v=ltfathelp('version');
                mlist=ltfathelp('modules');
     
        LTFATHELP displays some general help on the LTFAT toolbox.
     
        LTFATHELP('version') returns the version number.
     
        LTFATHELP('modules') returns a cell array of installed modules and
        corresponding version numbers.
     
     *Url*: <http://ltfat.github.io/doc/ltfathelp.html>

     See also: ltfatstart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LTFATHELP Help on the LTFAT toolbox
   Usage:  ltfathelp;
           v=ltfath...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1876
 -- Function: ltfatmex
     LTFATMEX   Compile Mex/Oct interfaces
        Usage:  ltfatmex;
                ltfatmex(...);
     
        LTFATMEX compiles the C backend in order to speed up the execution of
        the toolbox. The C backend is linked to Matlab and Octave through Mex
        and Octave C++ interfaces.
        Please see INSTALL-Matlab or INSTALL-Octave for the requirements.
     
        The action of LTFATMEX is determined by one of the following flags:
     
          'compile'  Compile stuff. This is the default.
     
          'clean'    Removes the compiled functions.
     
          'test'     Run some small tests that verify that the compiled
                     functions work.
     
        The target to work on is determined by on of the following flags.
     
        General LTFAT:
     
          'lib'      Perform action on the LTFAT C library.
     
          'mex'      Perform action on the mex / oct interfaces.
     
          'pbc'      Perform action on the PolyBoolClipper code for use with MULACLAB
     
          'auto'     Choose automatically which targets to work on from the 
                     previous ones based on the operation system etc. This is 
                     the default.
     
        Block-processing framework related:
     
          'playrec'  Perform action on the playrec code for use with real-time
                     block streaming framework.
     
          'java'     Perform compilation of JAVA classes into the bytecode.
                     The classes makes the GUI for the blockproc. framework.
     
        Other:
     
           'verbose' Print action details. 
     
           'debug'   Build a debug version. This will disable compiler 
                     optimizations and include debug symbols.
                     
     *Url*: <http://ltfat.github.io/doc/ltfatmex.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
LTFATMEX   Compile Mex/Oct interfaces
   Usage:  ltfatmex;
           ltfatme...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 538
 -- Function: ltfatsetdefaults
     LTFATSETDEFAULTS  Set default parameters of function
     
        LTFATSETDEFAULTS(fname,...) sets the default parameters to be the
        parameters specified at the end of the list of input arguments.
     
        LTFATSETDEFAULTS(fname) clears any default parameters for the function
        fname.
     
        LTFATSETDEFAULTS('clearall') clears all defaults from all functions.
     
     *Url*: <http://ltfat.github.io/doc/ltfatsetdefaults.html>

     See also: ltfatgetdefaults, ltfatstart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
LTFATSETDEFAULTS  Set default parameters of function



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1527
 -- Function: ltfatstart
     LTFATSTART   Start the LTFAT toolbox
        Usage:  ltfatstart;
     
        LTFATSTART starts the LTFAT toolbox. This command must be run
        before using any of the functions in the toolbox.
     
        To configure default options for functions, you can use the
        LTFATSETDEFAULTS function in your startup script. A typical startup
        file could look like:
     
          addpath('/path/to/my/work/ltfat');
          ltfatstart;
          ltfatsetdefaults('sgram','nocolorbar');
     
        This will add the main LTFAT directory to you path, start the
        toolbox, and configure SGRAM to not display the colorbar.
     
        The function walks the directory tree and adds a subdirectory 
        to path if the directory contain a [subdirectory,init.m] 
        script setting a status variable to some value greater than 0.   
        status==1 identifies a toolbox module any other value just a
        directory to be added to path.
     
        LTFATSTART(0) supresses any status messages.
     
        !!WARNING for MATLAB users!!
        ----------------------------
     
        The function indirectly calls clear all, which clears all your global
        and persistent variables. It comes with calling javaaddpath in
        blockproc/blockprocinit.m. You can avoid calling it by passing 
        additional 'nojava' flag.
     
     *Url*: <http://ltfat.github.io/doc/ltfatstart.html>

     See also: ltfatsetdefaults, ltfatmex, ltfathelp, ltfatstop.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
LTFATSTART   Start the LTFAT toolbox
   Usage:  ltfatstart;



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 253
 -- Function: ltfatstop
     LTFATSTOP   Stops the LTFAT toolbox
        Usage:  ltfatstop;
     
        LTFATSTOP removes all LTFAT subdirectories from the path.
     
     *Url*: <http://ltfat.github.io/doc/ltfatstop.html>

     See also: ltfatstart.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
LTFATSTOP   Stops the LTFAT toolbox
   Usage:  ltfatstop;



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3456
 -- Function: mulaclab
     MULACLAB Graphical interface for audio processing using frame multipliers
        Usage: mulaclab;
               mulaclab(filename);
               mulaclab(signal, fs);
     
        Input parameters:
              filename : File name of the signal to process.
              signal   : Signal to process, which must be a vector.
              fs       : Sampling frequency of the signal.
      
        When starting MULACLAB without any input parameter, the user is asked to
        choose the processed signal, named original signal in the interface.
     
        Possible signals are .wav files and .mat files containing decompositions
        preliminarily saved using the MULACLAB interface. The interface only
        handles monochannel signals. So for multichannel .wav files, the first
        channel is used as the original signal.
     
        Optionnaly, the file name of the original signal can be directly passed as
        an input parameter. The original signal can also be directly passed as a
        vector along its sampling frequency.  
     
        After choosing the original signal, the user is presented with the main
        interface. This interface is divided in two areas: 
     
         The right part of the figure contains the visualizations, which
          represent the spectrograms of the original and modified signals.
     
          The 'Original signal' visualization is used to display the original
          signal spectrogram and to graphically define the symbol of the frame
          multiplier that will be applied on this signal. 
     
          The 'Overview of original signal' visualization also represents the
          original signal spectrogram and can be used for fast zooming and moving
          of the other visualizations. Zooming and moving is controlled by mouse
          interaction with the white rectangle displayed on this visualization. 
     
          The 'Modified signal' visualization is used to display the spectrogram
          of the modified signal after application of the multiplier.
     
          It is possible to hide the 'Overview of original signal' and 'Modified
          signal' visulizations using the 'Visualization' menu.
     
         The left part of the figure contains panels with tools for user 
          interaction.
     
          The 'Audioplayer' panel contains the controls for audio playback of the
          original and modified signal.
     
          The 'Visualization' panel contains tools used to adapt the display
          of the visualizations.
     
          The 'Selection' panel contains tools and information concerning the
          multilayered selection used to graphically specify the symbol of the 
          multiplier.
      
        Known MATLAB limitations: 
     
         When using MATLAB on Linux with multiple screens, there might be a 
          MATLAB bug preventing the display of the multiplier symbol. This can be
          solved by docking the figure.
     
         When using a MATLAB version prior to 7.3 (R2006b), the rectangle
          displayed on the 'Overview of original signal' visualization is not
          automatically updated when using the zoom and pan tools of the 'Zoom' 
          panel. It can be manually updated by re-clicking on the currently
          selected tool or by changing the current tool.
     *Url*: <http://ltfat.github.io/doc/mulaclab.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
MULACLAB Graphical interface for audio processing using frame multipliers
   ...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1444
 -- Function: scalardistribute
     SCALARDISTRIBUTE  Copy scalar to array shape for parameter handling
        Usage:  [...] = scalardistribute(...);
     
        [...]=SCALARDISTRIBUTE(...) copies the input parameters to the
        output parameters.
     
         If one of the input parameters is an array, all the output parameters
          will be column vectors containing the same number of elements. If one
          of the other input parameters is a scalar, it will be replicated to
          the correct length. This allows a scalar value to be repeated for
          all conditions.
     
         If two or more input parameters are arrays, the must have the exact
          same size. They will be converted to vectors and returned in the
          output parameters. This allows two arrays to co-vary at the same time.
     
        This operator is usefull for sanitizing input parameters: The user is
        allowed to enter scalars or arrays as input paremeters. These input
        are in turn passed to SCALARDISTRIBUTE, which makes sure that the
        arrays have the same shape, and that scalars are replicated. The user
        of scalardistibute can now generate conditions based on all the
        parameters, and be sure the have the right sizes.
     
        As an example, consider:
     
          [a,b,c]=scalardistribute(1,[2,3],[4,5])
     
     *Url*: <http://ltfat.github.io/doc/scalardistribute.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
SCALARDISTRIBUTE  Copy scalar to array shape for parameter handling
   Usage:...





