# doc-cache created by Octave 4.0.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: 860
 LTFAT - Base routines

  Peter L. Soendergaard, 2009 - 2015.

  Basic routines
    LTFATSTART       -  Start the toolbox
    LTFATSTOP        -  Stop the toolbox
    LTFATHELP        -  Help
    LTFATMEX         -  Compile Mex/Oct interfaces
    LTFATBASEPATH    -  Return the base path
    ISOCTAVE         -  True if interpreter is Octave

  Parameter handling
    LTFATARGHELPER   -  Handle optional parameters of functions
    LTFATGETDEFAULTS -  Get the default values for a function
    LTFATSETDEFAULTS -  Get the default values for a function
    SCALARDISTRIBUTE -  Expand parameters to common size

  Graphical user interfaces
    MULACLAB         -  Short Time-Fourier transform modification in Matlab

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

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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
 LTFAT - Base routines



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


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

     *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]  = ltfatar



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 314
 -- 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 = ltfatbasep



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 372
 -- 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: 501
 -- 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=ltfathelp



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


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

          'gpc'      Perform action on the GPC 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;
           ltfatmex(.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 518
 -- 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: 1476
 -- 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: 243
 -- 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: 16
scalardistribute


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 172
 -- Function: test_all_ltfat
      Testing of pbspline has been removed, as it causes too much trouble.
     *Url*: <http://ltfat.github.io/doc/testing/test_all_ltfat.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
 Testing of pbspline has been removed, as it causes too much trouble.





