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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2601
 LTFAT - Demos

   Peter L. Soendergaard, 2007 - 2023.

   This page documents the demos.

   Basic demos
     DEMO_DGT              - DGT and comparison to SGRAM
     DEMO_DGT_PARAMETRIZE  - Calculate the STFT
     DEMO_GABFIR           - FIR windows in Gabor systems.
     DEMO_WAVELETS         - Wavelet representations using  FWT and WFBT.

   Compression
     DEMO_IMAGECOMPRESSION - Image compression using DWILT and FWT
     DEMO_AUDIOCOMPRESSION - Audio compression using a WMDCT.

   Denoising 
     DEMO_AUDIODENOISE     - Audio denoising using a WMDCT.

   Applications
     DEMO_OFDM             - Simple OFDM demo.
     DEMO_AUDIOSHRINK      - Lasso shrinkage of audio signal.
     DEMO_GABMULAPPR       - Approx. of time-varying system.
     DEMO_BPFRAMEMUL       - A Gabor multiplier as a time-varying bandpass filter.
     DEMO_FRSYNABS         - Synthetic spectrogram iterative reconstruction.
     DEMO_FILTERBANKSYNCHROSQUEEZE - Reconstruction from synchrosqueezed representation.
     DEMO_TFJIGSAWSEP      - Time-Frequency jigsaw puzzle tonal-transient-residual separation

   Aspects of particular functions
     DEMO_NSDGT            - Non-stationary Gabor systems
     DEMO_PGAUSS           - How to use PGAUSS.
     DEMO_PBSPLINE         - How to use PBSPLINE.
     DEMO_GABMIXDUAL       - How to use GABMIXDUAL.
     DEMO_FRAMEMUL         - Time-frequency localization by Gabor multiplier.
     DEMO_PHASEPLOT        - Phaseplots.
     DEMO_PHASERET         - Spectrogram phase retrieval and phase difference
     DEMO_NEXTFASTFFT      - Next fast FFT size.
     DEMO_FILTERBANKS      - Non-stationary Gabor systems defined in frequency domain

  Auditory scales and filters
     DEMO_AUDSCALES          - Different auditory scales.
     DEMO_AUDITORYFILTERBANK - Erb-spaced auditory filter bank.
     DEMO_WFBT               - Auditory filter banks created using WFBT.

  Block-processing demos
     DEMO_BLOCKPROC_BASICLOOP        - Simple audio playback loop.
     DEMO_BLOCKPROC_PARAMEQUALIZER   - Parametric equalizer.
     DEMO_BLOCKPROC_DENOISING        - Variable noise-reduction.
     DEMO_BLOCKPROC_SLIDINGSGRAM     - Sliding spectrogram plot.
     DEMO_BLOCKPROC_SLIDINGCQT       - Sliding CQT plot.
     DEMO_BLOCKPROC_SLIDINGERBLETS   - Sliding Erblets plot.
     DEMO_BLOCKPROC_DGTEQUALIZER     - Variable Gabor Multiplier as equalizer.
     DEMO_BLOCKPROC_EFFECTS          - Real-time vocoder effects.
     

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

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



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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1167
 -- Function: demo_audiocompression
     DEMO_AUDIOCOMPRESSION  Audio compression using N-term approx
     
        This demos shows how to do audio compression using best N-term
        approximation of an WMDCT transform.
     
        The signal is transformed using an orthonormal WMDCT transform.
        Then approximations with a fixed number N of coefficients are obtained
        by:
     
           Linear approximation: The N coefficients with lowest frequency
            index are kept.
     
           Non-linear approximation: The N largest coefficients (in
            magnitude) are kept.
     
        The corresponding approximated signal can be computed using IWMDCT.
     
        Figure 1: Rate-distorition plot
     
           The figure shows the output Signal to Noise Ratio (SNR) as a function
           of the number of retained coefficients.
     
        Note: The inverse WMDCT is not needed for computing computing
        SNRs. Instead Parseval theorem states that the norm of a signal equals
        the norm of the sequence of its WMDCT coefficients.
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_audiocompression.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
DEMO_AUDIOCOMPRESSION  Audio compression using N-term approx



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 681
 -- Function: demo_audiodenoise
     DEMO_AUDIODENOISE  Audio denoising using thresholding
     
        This demos shows how to do audio denoising using thresholding
        of WMDCT transform.
     
        The signal is transformed using an orthonormal WMDCT transform
        followed by a thresholding. Then the signal is reconstructed
        and compared with the original.
     
        Figure 1: Denoising
     
           The figure shows the original signal, the noisy signal and denoised
           signals using hard and soft threshholding applied to the WMDCT of the
           noise signal.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_audiodenoise.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
DEMO_AUDIODENOISE  Audio denoising using thresholding



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1357
 -- Function: demo_audioshrink
     DEMO_AUDIOSHRINK  Decomposition into tonal and transient parts
     
        This demos shows how to do audio coding and "tonal + transient"
        decomposition using group lasso shrinkage of two WMDCT transforms
        with different time-frequency resolutions.
     
        The signal is transformed using two orthonormal WMDCT bases.
        Then group lasso shrinkage is applied to the two transforms
        in order to:
     
           select fixed frequency lines of large WMDCT coefficients on the
            wide window WMDCT transform
     
           select fixed time lines of large WMDCT coefficients on the
            narrow window WMDCT transform
      
        The corresponding approximated signals are computed with the
        corresponding inverse, IWMDCT.
     
        Figure 1: Plots and time-frequency images
     
           The upper plots in the figure show the tonal parts of the signal, the
           lower plots show the transients. The TF-plots on the left are the
           corresponding wmdct coefficients found by appropriate group lasso
           shrinkage
     
        Corresponding reconstructed tonal and transient sounds may be
        listened from arrays rec1 and rec2 (sampling rate: 44.1 kHz)
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_audioshrink.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
DEMO_AUDIOSHRINK  Decomposition into tonal and transient parts



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1541
 -- Function: demo_auditoryfilterbank
     DEMO_AUDITORYFILTERBANK  Construct an auditory filterbank
     
        In this file we construct a uniform filterbank using a the impulse
        response of a 4th order gammatone for each channel. The center frequencies
        are equidistantly spaced on an ERB-scale, and the width of the filters are
        chosen to match the auditory filter bandwidth as determined by Moore.
     
        Each channel is subsampled by a factor of 8 (a=8), and to generate a
        nice plot, 4 channels per Erb have been used.
     
        The filterbank covers only the positive frequencies, so we must use
        FILTERBANKREALDUAL and FILTERBANKREALBOUNDS.
     
        Figure 1: Classic spectrogram
     
           A classic spectrogram of the spoken sentense. The dynamic range has
           been set to 50 dB, to highlight the most important features.
     
        Figure 2: Auditory filterbank representation
     
           Auditory filterbank representation of the spoken sentense using
           gammatone filters on an Erb scale.  The dynamic range has been set to
           50 dB, to highlight the most important features.
     
     
        References:
          B. R. Glasberg and B. Moore. Derivation of auditory filter shapes from
          notched-noise data. Hearing Research, 47(1-2):103, 1990.
          
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_auditoryfilterbank.html>

     See also: freqtoaud, audfiltbw, gammatonefir, ufilterbank,
     filterbankrealdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
DEMO_AUDITORYFILTERBANK  Construct an auditory filterbank



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 531
 -- Function: demo_audscales
     DEMO_AUDSCALES  Plot of the different auditory scales
     
        This demos generates a simple figure that shows the behaviour of
        the different audiory scales in the frequency range from 0 to 8000 Hz.
     
        Figure 1: Auditory scales
     
           The figure shows the behaviour of the audiory scales on a normalized
           frequency plot.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_audscales.html>

     See also: freqtoaud, audtofreq, audspace, audspacebw.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
DEMO_AUDSCALES  Plot of the different auditory scales



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 404
 -- Function: demo_blockproc_basicloop
     DEMO_BLOCKPROC_BASICLOOP Basic real-time audio manipulation
        Usage: demo_blockproc_basicloop('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_BASICLOOP without arguments.
     
        The demo runs simple playback loop allowing to set gain in dB.
      
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_basicloop.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_BASICLOOP Basic real-time audio manipulation
   Usage: demo_bl...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 455
 -- Function: demo_blockproc_denoising
     DEMO_BLOCKPROC_DENOISING Variable coefficients thresholding
        Usage: demo_blockproc_denoising('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_DENOISING without arguments.
     
        The present demo allows you to set the coefficient threshold during the
        playback using the control panel.
      
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_denoising.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_DENOISING Variable coefficients thresholding
   Usage: demo_bl...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 748
 -- Function: demo_blockproc_dgtequalizer
     DEMO_BLOCKPROC_DGTEQUALIZER Real-time audio manipulation in the transform domain
        Usage: demo_blockproc_dgtequalizer('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_DGTEQUALIZER without arguments.
     
        This script demonstrates a real-time Gabor coefficient manipulation.
        Frequency bands of Gabor coefficients are multiplied (weighted) by
        values taken from sliders having a similar effect as a octave equalizer.
        The shown spectrogram is a result of a re-analysis of the synthetized 
        block to show a frequency content of what is actually played. 
     
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_dgtequalizer.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_DGTEQUALIZER Real-time audio manipulation in the transform dom...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1309
 -- Function: demo_blockproc_effects
     DEMO_BLOCKPROC_EFFECTS Various vocoder effects using DGT
        Usage: demo_blockproc_effects('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_EFFECTS without arguments.
        This demo works correctly only with the sampling rate equal to 44100 Hz.
     
        This script demonstrates several real-time vocoder effects. Namely:
     
           1) Robotization effect: Achieved by doing DGT reconstruction using
              absolute values of coefficients only.
     
           2) Whisperization effect: Achieved by randomizing phase of DGT
              coefficients.
     
           3) Pitch shifting effect: Achieved by stretching/compressing
              coefficients along frequency axis.
     
           4) Audio morphing: Input is morphed with a background sound such
              that the phase of DGT coefficients is substituted by phase
              of DGT coefficients of the background signal. 
              File beat.wav (at 44,1kHz) (any sound will do) is expected to 
              be in the search path, oherwise the effect will be disabled.   
     
        This demo was created for the Lange Nacht der Forschung 4.4.2014 event.
        
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_effects.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_EFFECTS Various vocoder effects using DGT
   Usage: demo_block...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 619
 -- Function: demo_blockproc_paramequalizer
     DEMO_BLOCKPROC_PARAMEQUALIZER Real-time equalizer demonstration
        Usage: demo_blockproc_paramequalizer('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_PARAMEQUALIZER without arguments.
     
        This demonstration shows an example of a octave parametric
        equalizer. See chapter 5.2 in the book by Zolzer.
      
        References:
          U. Zolzer. Digital Audio Signal Processing. John Wiley and Sons Ltd, 2
          edition, 2008.
          
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_paramequalizer.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_PARAMEQUALIZER Real-time equalizer demonstration
   Usage: dem...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 452
 -- Function: demo_blockproc_slidingcqt
     DEMO_BLOCKPROC_SLIDINGCQT Basic real-time rolling CQT-spectrogram visualization
        Usage: demo_blockproc_slidingcqt('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_SLIDINGCQT without arguments.
     
        This demo shows a simple rolling CQT-spectrogram of whatever is specified in
        source. 
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_slidingcqt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_SLIDINGCQT Basic real-time rolling CQT-spectrogram visualizati...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 478
 -- Function: demo_blockproc_slidingerblets
     DEMO_BLOCKPROC_SLIDINGERBLETS Basic real-time rolling erblet-spectrogram visualization
        Usage: demo_blockproc_slidingerblets('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_SLIDINGERBLETS without arguments.
     
        This demo shows a simple rolling erblet-spectrogram of whatever is specified in
        source. 
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_slidingerblets.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_SLIDINGERBLETS Basic real-time rolling erblet-spectrogram visu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 454
 -- Function: demo_blockproc_slidingsgram
     DEMO_BLOCKPROC_SLIDINGSGRAM Basic real-time rolling spectrogram visualization
        Usage: demo_blockproc_slidingsgram('gspi.wav')
     
        For additional help call DEMO_BLOCKPROC_SLIDINGSGRAM without arguments.
     
        This demo shows a simple rolling spectrogram of whatever is specified in
        source. 
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_blockproc_slidingsgram.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_BLOCKPROC_SLIDINGSGRAM Basic real-time rolling spectrogram visualization...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1042
 -- Function: demo_bpframemul
     DEMO_BPFRAMEMUL Frame multiplier acting as a time-varying bandpass filter
     
        This demo demonstrates creation and effect of a Gabor multiplier. The
        multiplier performs a time-varying bandpass filtering. The band-pass
        filter with center frequency changing over time is explicitly created
        but it is treated as a "black box" system. The symbol is identified by
        "probing" the system with a white noise and dividing DGT of the output
        by DGT of the input element-wise. The symbol is smoothed out by a 5x5
        median filter.
     
        Figure 1: The symbol of the multiplier.
     
           This figure shows a symbol used in the Gabor multiplier.
     
        Figure 2: Spectroram obtained by re-analysis of the test signal after applying the multiplier
     
           This figure shows a spectrogram of the test signal after applying
           the estimated Gabor multiplier.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_bpframemul.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
DEMO_BPFRAMEMUL Frame multiplier acting as a time-varying bandpass filter



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1401
 -- Function: demo_dgt
     DEMO_DGT  Basic introduction to DGT analysis/synthesis
     
        This demo shows how to compute Gabor coefficients of a signal.
     
        Figure 1: Spectrogram of the 'bat' signal.
     
           The figure shows a spectrogram of the 'bat' signal. The
           coefficients are shown on a linear scale.
     
        Figure 2: Gabor coefficients of the 'bat' signal.
     
           The figure show a set of Gabor coefficients for the 'bat' signal,
           computed using a DGT with a Gaussian window. The coefficients
           contains all the information to reconstruct the signal, even though
           there a far fewer coefficients than the spectrogram contains.
     
        Figure 3: Real-valued Gabor analysis
     
           This figure shows only the coefficients for the positive
           frequencies. As the signal is real-value, these coefficients
           contain all the necessary information. Compare to the shape of the
           spectrogram shown on Figure 1.
     
        Figure 4: DGT coefficients on a spectrogram
     
           This figure shows how the coefficients from DGTREAL can be picked
           from the coefficients computed by a full Short-time Fourier
           transform, as visualized by a spectrogram.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_dgt.html>

     See also: sgram, dgt, dgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
DEMO_DGT  Basic introduction to DGT analysis/synthesis



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 690
 -- Function: demo_dgt_parametrize
     DEMO_DGT_PARAMETRIZE shows how to parametrize the DGT algorithm
     
        This demo shows two ways of parametrizing the discrete Gabor
        transform. In the first part, it is shown how to parametrize
        the dgt to yield a specified signal length for a given window
        length and overlap.
        In the second part, the dgt algorithm is used to calculate a
        classical short-time Fourier transform with a = b = 1.
     
        Figure 1: Spectrogram of the 'gspi' signal.
     
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_dgt_parametrize.html>

     See also: dgt, dgtreal, idgt, idgtreal, gabimagepars, demo_dgt.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
DEMO_DGT_PARAMETRIZE shows how to parametrize the DGT algorithm



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2565
 -- Function: demo_filterbanks
     DEMO_FILTERBANKS  CQT, ERBLET and AUDLET filterbanks
     
        This demo shows CQT (Constant Quality Transform), ERBLET (Equivalent
        Rectangular Bandwidth -let transform), and AUDLET (Auditory -let) 
        representations acting as filterbanks  with high and low redundancies.
        Note that ERBLET and AUDLET are similar concepts. The main difference
        is that ERBlet uses only the perceptual ERB scale while AUDlet allows
        for various perceptual scales like Bark or Mel scales. In short,
        ERBFILTERS is a wrapper of AUDFILTERS for the ERB scale. 
        Filterbanks are build such that the painless condition is always satisfied.
        Real input signal and filters covering only the positive frequency range 
        are used. The redundancy is calculated as a ratio of the number of (complex) 
        coefficients and the input length times two to account for the storage
        requirements of complex numbers.
     
           The high redundancy representation uses 'uniform' subsampling i.e.
            all channels are subsampled with the same subsampling factor which
            is the lowest from the filters according to the painless condition
            rounded towards zero.
     
           The low redundancy representation uses 'fractional' subsampling
            which results in the least redundant representation still
            satisfying the painless condition. Actual time positions of atoms 
            can be non-integer, hence the word fractional.
     
        Figure 1: ERBLET representations
     
           The high-redundancy plot (top) consists of 400 channels (~9 filters 
           per ERB) and the low-redundancy plot (bottom) consists of 44 channels 
           (1 filter per ERB).
     
        Figure 2: CQT representations
     
           Both representations consist of 280 channels (32 channels per octave,
           frequency range 50Hz-20kHz). The high-redundany represention is on 
           the top and the low-redundancy repr. is on the bottom.
      
        Figure 3: AUDLET representations
     
           The first representation consists of 72 channels BARKlet FB (3 filters
           per Bark in the frequency range 100Hz-16kHz using fractional subsampling.
           The second representation consists of 40 channels MELlet FB using
           uniform subsampling and triangular windows.
     
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_filterbanks.html>

     See also: audfilters, erbfilters, cqtfilters.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
DEMO_FILTERBANKS  CQT, ERBLET and AUDLET filterbanks



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1571
 -- Function: demo_filterbanksynchrosqueeze
     DEMO_FILTERBANKSYNCHROSQUEEZE Filterbank synchrosqueezing and inversion
     
        The demo shows that the synchrosqueezed filterbank representation can be 
        directly used to reconstruct the original signal.
        Since we do not work with a filterbank which forms a tight frame 
        (its FILTERBANKRESPONSE is not constant) the direct reconstruction 
        (mere summing all the channels) does not work well. We can fix that by
        filtering (equalizing) the result by the inverse of the overall analysis 
        filterbank frequency response.
     
        Figure 1: ERBlet spectrogram (top) and synchrosqueezed ERBlet spectrogram (bottom)
     
           The signal used is the first second from GSPI. Only the energy of
           the coefficients is show. Both representations are in fact complex and
           invertible.
     
        Figure 2: Errors of the direct and the equalized reconstructions
            
           There is still a small DC offset of the signal obtained by the direct
           summation.
     
        References:
          N. Holighaus, Z. Průša, and P. L. Soendergaard. Reassignment and
          synchrosqueezing for general time-frequency filter banks, subsampling
          and processing. Signal Processing, 125:1--8, 2016. [1]http ]
          
          References
          
          1. http://www.sciencedirect.com/science/article/pii/S0165168416000141
          
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_filterbanksynchrosqueeze.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
DEMO_FILTERBANKSYNCHROSQUEEZE Filterbank synchrosqueezing and inversion



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1019
 -- Function: demo_framemul
     DEMO_FRAMEMUL  Time-frequency localization by a Gabor multiplier
     
        This script creates several different time-frequency symbols
        and demonstrate their effect on a random, real input signal.
     
        Figure 1: Cut a circle in the TF-plane
     
           This figure shows the symbol (top plot, only the positive frequencies are displayed),
           the input random signal (bottom) and the output signal (middle).
     
        Figure 2: Keep low frequencies (low-pass)
     
           This figure shows the symbol (top plot, only the positive frequencies are displayed),
           the input random signal (bottom) and the output signal (middle).
     
        Figure 3: Keep middle frequencies (band-pass)
     
           This figure shows the symbol (top plot, only the positive frequencies are displayed),
           the input random signal (bottom) and the output signal (middle).
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_framemul.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
DEMO_FRAMEMUL  Time-frequency localization by a Gabor multiplier



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 987
 -- Function: demo_frsynabs
     DEMO_FRSYNABS  Construction of a signal with a given spectrogram
     
        This demo demonstrates iterative reconstruction of a spectrogram.
     
        Figure 1: Original spectrogram
     
           This figure shows the target spectrogram
     
        Figure 2: Linear reconstruction
     
           This figure shows a spectrogram of a linear reconstruction of the
           target spectrogram.
     
        Figure 3: Iterative reconstruction using the Griffin-Lim method.
     
           This figure shows a spectrogram of an iterative reconstruction of the
           target spectrogram using the Griffin-Lim projection method.
     
        The BFGS method makes use of the minFunc software. To use the BFGS method, 
        please install the minFunc software from:
        http://www.cs.ubc.ca/~schmidtm/Software/minFunc.html.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_frsynabs.html>

     See also: isgramreal, isgram.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
DEMO_FRSYNABS  Construction of a signal with a given spectrogram



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2309
 -- Function: demo_gabfir
     DEMO_GABFIR  Working with FIR windows
     
        This demo demonstrates how to work with FIR windows in Gabor systems.
     
        FIR windows are the windows traditionally used in signal processing.
        They are short, much shorter than the signal, and this is used to make
        effecient algorithms. They are also the only choice for applications
        involving streaming data.
     
        It is very easy to compute a spectrogram or Gabor coefficients using a
        FIR window. The hard part is reconstruction, because both the window and
        the dual window used for reconstruction must be FIR, and this is hard
        to obtain, if the window is longer than the number of channels.
     
        This demo demonstrates two methods:
     
          1) Using a Gabor frame with a simple structure, for which dual/tight
             FIR windows are easy to construct. This is a very common
             technique in traditional signal processing, but it limits the
             choice of windows and lattice parameters.
     
          2) Cutting a canonical dual/tight window. We compute the canonical
             dual window of the analysis window, and cut away the parts that
             are close to zero. This will work for any analysis window and
             any lattice constant, but the reconstruction obtained is not
             perfect.
     
        Figure 1: Hanning FIR window
     
           This figure shows the a Hanning window in the time domain and its
           magnitude response.
     
        Figure 2: Kaiser-Bessel FIR window
     
           This figure shows a Kaiser Bessel window and its magnitude response,
           and the same two plots for the canonical dual of the window.
     
        Figure 3: Gaussian FIR window for low redundancy
     
           This figure shows a truncated Gaussian window and its magnitude
           response. The same two plots are show for the truncated canonical
           dual window.
     
        Figure 4: Almost tight Gaussian FIR window
     
           This figure shows a tight Gaussian window that has been truncated
           and its magnitude response.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_gabfir.html>

     See also: firwin, firkaiser, gabdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 37
DEMO_GABFIR  Working with FIR windows



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1415
 -- Function: demo_gabmixdual
     DEMO_GABMIXDUAL  How to use GABMIXDUAL
     
        This script illustrates how one can produce dual windows
        using GABMIXDUAL
     
        The demo constructs a dual window that is more concentrated in
        the time domain by mixing the original Gabor window by one that is
        extremely well concentrated. The result is somewhat in the middle
        of these two.
      
        The lower framebound of the mixing Gabor system is horrible,
        but this does not carry over to the gabmixdual.
     
        Figure 1: Gabmixdual of two Gaussians.
     
           The first row of the figure shows the canonical dual window
           of the input window, which is a Gaussian function perfectly
           localized in the time and frequency domains.
     
           The second row shows the canonical dual window of the window we
           will be mixing with: This is a Gaussian that is 10 times more
           concentrated in the time domain than in the frequency domain.
           The resulting canonical dual window has rapid decay in the time domain.
     
           The last row shows the gabmixdual of these two. This is a non-canonical
           dual window of the first Gaussian, with decay resembling that of the
           second.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_gabmixdual.html>

     See also: gabmixdual, gabdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
DEMO_GABMIXDUAL  How to use GABMIXDUAL



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 793
 -- Function: demo_gabmulappr
     DEMO_GABMULAPPR Approximate a slowly time variant system by a Gabor multiplier
        
        This script construct a slowly time variant system and performs the 
        best approximation by a Gabor multiplier with specified parameters
        (a and L see below). Then it shows the action of the slowly time 
        variant system (A) as well as of the best approximation of (A) by a 
        Gabor multiplier (B) on a sinusoids and an exponential sweep.
     
        Figure 1: Spectrogram of signals
     
           The figure shows the spectogram of the output of the two systems applied on a 
           sinusoid (left) and an exponential sweep.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_gabmulappr.html>

     See also: gabmulappr.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_GABMULAPPR Approximate a slowly time variant system by a Gabor multiplie...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1210
 -- Function: demo_imagecompression
     DEMO_IMAGECOMPRESSION  Image compression using N-term approximation
     
        This demo shows how to perform a simple imagecompression using either
        a Wilson basis or a Wavelet. The compression step is done by
        retaining only 5% of the coefficients. 
     
        Figure 1: Wilson and WMDCT basis
     
           This right figure shows the image compressed using a DWILT basis with
           8 channels. This corresponds quite closely to JPEG compression,
           except that the borders between neigbouring blocs are smoother,
           since the DWILT uses a windowing function.
     
           The left figure shows the same, now
           using a MDCT basis. The MDCT produces more visible artifacts, as the
           slowest changing frequency in each block has a half-wave
           modulation. This is visible on otherwise smooth backgrounds.
     
        Figure 2: Wavelet
     
           The Wavelet used is the DB6 with J=5 levels. On the right figure
           the standard layout has been used, on the left the tensor layout
           was used.
     *Url*:
     <http://ltfat.github.io/doc/demos/demo_imagecompression.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
DEMO_IMAGECOMPRESSION  Image compression using N-term approximation



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 843
 -- Function: demo_nextfastfft
     DEMO_NEXTFASTFFT  Next fast FFT number
     
        This demo shows the behaviour of the NEXTFASTFFT function.
     
        Figure 1: Benchmark of the FFT routine
     
           The figure shows the sizes returned by the NEXTFASTFFT function
           compared to using nextpow2. As can be seen, the NEXTFASTFFT
           approach gives FFT sizes that are much closer to the input size.
     
        Figure 2: Efficiency of the table
     
           The figure show the highest output/input ratio for varying input
           sizes. As can be seen, the efficiency is better for larger input
           values, where the output size is at most a few percent larger than
           the input size.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_nextfastfft.html>

     See also: nextfastfft.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
DEMO_NEXTFASTFFT  Next fast FFT number



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 788
 -- Function: demo_nsdgt
     DEMO_NSDGT  Non-stationary Gabor transform demo
     
        This script sets up a non-stationary Gabor frame with the specified
        parameters, computes windows and corresponding canonical dual windows
        and a test signal, and plots the windows and the energy of the 
        coefficients.
     
        Figure 1: Windows + dual windows
      
           This figure shows the window functions used and the corresponding
           canonical dual windows. 
     
        Figure 2: Spectrogram (absolute value of coefficients in dB)
     
           This figure shows a (colour-coded) image of the nsdgt coefficient
           modulus. 
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_nsdgt.html>

     See also: nsdgt, insdgt, nsgabdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
DEMO_NSDGT  Non-stationary Gabor transform demo



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2014
 -- Function: demo_ofdm
     DEMO_OFDM  Demo of Gabor systems used for OFDM
     
        This demo shows how to use a Gabor Riesz basis for OFDM.
     
        We want to transmit a signal consisting of 0's and 1's through a
        noisy communication channel. This is accomplished in the following
        steps in the demo:
     
          1) Convert this digital signal into complex valued coefficients by
             QAM modulation.
     
          2) Construct the signal to be transmitted by an inverse Gabor
             transform of the complex coefficients
     
          3) "Transmit" the signal by applying a spreading operator to the
             signal and adding white noise
     
          4) Convert the received signal into noisy coefficients by a Gabor
             transform
     
          5) Convert the noisy coefficients into bits by inverse QAM.
     
        Some simplifications used to make this demo simple:
     
           We assume that the whole spectrum is available for transmission.
     
           The window and its dual have full length support. This is not
            practical, because all data would have to be processed at once.
            Instead, an FIR should be used, with both the window and its dual
            having a short length.
     
           The window is periodic. The data at the very end interferes with
            the data at the very beginning. A simple way to solve this is to
            transmit zeros at the beginning and at the end, to flush the system
            properly.
     
        Figure 1: Received coefficients.
     
           This figure shows the distribution in the complex plane of the 
           received coefficients. If the channel was perfect, all the points
           should appear at the complex roots of unity (1,i,-1 and -i). This
           demo is random, so everytime it is run it produces a new plot, and
           the error rate may vary.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_ofdm.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
DEMO_OFDM  Demo of Gabor systems used for OFDM



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 650
 -- Function: demo_pbspline
     DEMO_PBSPLINE  How to use PBSPLINE
     
        This script illustrates various properties of the
        PBSPLINE function.
     
        Figure 1: Three first splines
     
           This figure shows the three first splines (order 0,1 and 2)
           and their dual windows.
     
           Note that they are calculated for an even number of the parameter a,
           meaning that they are not exactly splines, but a slightly smoother
           construction, that still form a partition of unity.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_pbspline.html>

     See also: pbspline, middlepad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
DEMO_PBSPLINE  How to use PBSPLINE



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 463
 -- Function: demo_pgauss
     DEMO_PGAUSS  How to use PGAUSS
     
        This script illustrates various properties of the Gaussian function.
     
        Figure 1: Window+Dual+Tight
     
           This figure shows an optimally centered Gaussian for a 
           given Gabor system, its canonical dual and tight windows
           and the DFTs of these windows.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_pgauss.html>

     See also: pgauss.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
DEMO_PGAUSS  How to use PGAUSS



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2533
 -- Function: demo_phaseplot
     DEMO_PHASEPLOT  Give demos of nice phaseplots
     
        This script creates a synthetic signal and then uses PHASEPLOT on it,
        using several of the possible options.
      
        For real-life signal only small parts should be analyzed. In the chosen
        demo the fundamental frequency of the speaker can be nicely seen.
     
        Figure 1: Synthetic signal
     
           Compare this to the pictures in reference 2 and 3. In 
           the first two figures a synthetic signal is analyzed. It consists of a 
           sinusoid, a small Delta peak, a periodic triangular function and a 
           Gaussian. In the time-invariant version in the first part the periodicity 
           of the sinusoid can be nicely seen also in the phase coefficients. Also
           the points of discontinuities can be seen as asymptotic lines approached
           by parabolic shapes. In the third part both properties, periodicity and 
           discontinuities can be nicely seen. A comparison to the spectogram shows 
           that the rectangular part in the middle of the signal can be seen by the
           phase plot, but not by the spectogram.
      
           In the frequency-invariant version, the fundamental frequency of the
           sinusoid can still be guessed as the position of an horizontal
           asymptotic line.
     
        Figure 2: Synthetic signal, thresholded.
     
           This figure shows the same as Figure 1, except that values with low
           magnitude has been removed.
     
        Figure 3: Speech signal.
     
           The figure shows a part of the 'linus' signal. The fundamental
           frequency of the speaker can be nicely seen.
     
        References:
          R. Carmona, W. Hwang, and B. Torresani. Multiridge detection and
          time-frequency reconstruction. IEEE Trans. Signal Process.,
          47:480--492, 1999.
          
          R. Carmona, W. Hwang, and B. Torresani. Practical Time-Frequency
          Analysis: continuous wavelet and Gabor transforms, with an
          implementation in S, volume 9 of Wavelet Analysis and its Applications.
          Academic Press, San Diego, 1998.
          
          A. Grossmann, M. Holschneider, R. Kronland-Martinet, and J. Morlet.
          Detection of abrupt changes in sound signals with the help of wavelet
          transforms. Inverse Problem, pages 281--306, 1987.
          
     *Url*: <http://ltfat.github.io/doc/demos/demo_phaseplot.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
DEMO_PHASEPLOT  Give demos of nice phaseplots



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 782
 -- Function: demo_phaseret
     DEMO_PHASERET Phase retrieval and phase difference
     
        This demo demonstrates iterative reconstruction of a spectrogram and
        the phase difference.
     
        Figure 1: Original spectrogram
     
           This figure shows the target spectrogram of an excerpt of the gspi
           signal
     
        Figure 2: Phase difference
     
           This figure shows a difference between the original phase and the 
           reconstructed using 100 iterations of a Fast Griffin-Lim algorithm.
           Note: The figure in the LTFAT 2.0 paper differs slightly because it
           is genarated using 1000 iterations.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_phaseret.html>

     See also: frsynabs, plotframe.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
DEMO_PHASERET Phase retrieval and phase difference



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2224
 -- Function: demo_tfjigsawsep
     DEMO_TFJIGSAWSEP - Decomposition of an audio signal into tonal, transient and residual layers
     
        This demo shows how to use tfjigsawsep, where a signal is decomposed
        into its tonal, transient and noisy residual layers. 
        
        The algorithm is based on [1]. It transforms a signal into a two-windowed
        Gabor expansion such that one wide window shall lead to a high frequency
        resolution (tonal layer is represented well) and a narrow one to a high
        time resolution (transient layer is repr. well). The resulting Gabor
        coefficients in the time-frequency plane are grided adaptively into rectangular
        'supertiles', whithin one by one an entropy criterion decides, which
        layer of the signal (tonal, transient) is represented better. This tile
        will be kept if it is below a certain threshold, the other one is thrown
        away. After running through the whole tf-plane, the respectively
        leftover Gabor coefficients are transformed back and substracted 
        from the original signal. By applying this procedure iteratively,
        tonal and transient layers emerge.
        A second version of the algorithm is available. Here the entropy
        criterion chooses those tiles, where the tonal part of the signal is
        represented better and is below a given threshold. The rest is set to
        zero. The leftover Gabor coefficients are transformed back and
        substracted from the original signal. Then the same is applied again to
        choose those tiles, where the transient part is represented better.
        After that, one gets the first approximation of the two layers. By
        applying this procedure iteratively on the residual, tonal and
        transient layers emerge.
        
        Figure 1: Separated layers
           
     
        References:
          F. Jaillet and B. Torresani. Time-frequency jigsaw puzzle: Adaptive
          multiwindow and multilayered gabor expansions. IJWMIP, 5(2):293--315,
          2007.
          
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_tfjigsawsep.html>

     See also: tfjigsawsep, plottfjigsawsep, dgtreal.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
DEMO_TFJIGSAWSEP - Decomposition of an audio signal into tonal, transient and...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1630
 -- Function: demo_waveletfilters
     DEMO_WAVELETFILTERS  Invertible wavelet filter banks via grid-like sampling
     
        This demo shows how to generate invertible wavelet filter 
        banks.
     
        The following wavelet filter banks are produced:
     
     
        Figure 1: Non-uniformly sampled wavelet filter bank
     
           The figure shows a non-uniformly sampled invertible filter bank with 
           conventional, geometric frequency spacing.
     
     
        Figure 2: Non-uniformly sampled wavelet filter bank
     
           The figure shows a non-uniformly sampled invertible filter bank with 
           geometric frequency spacing, a higher redundancy and using
           a wavelet with different Q-factor.
     
     
        Figure 3: Uniformly sampled wavelet filter bank
     
           The figure shows a uniformly sampled invertible filter bank with geometric 
           frequency spacing, where the scales are passed directly as input
           arguments.
     
     
        Figure 4: Uniformly sampled wavelet filter bank
     
           The figure shows a uniformly sampled invertible filter bank with linear 
           frequency spacing where the compensation channel index is passed directly.
           invertibility is achieved by passing a small delay to the filter
           generator.
     
     
        Figure 5: The figure shows a comparison of the filter center frequency spacing.
     
     
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_waveletfilters.html>

     See also: waveletfilters, freqwavelet, lowdiscrepancy,
     filterbankrealdual.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
DEMO_WAVELETFILTERS  Invertible wavelet filter banks via grid-like sampling



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1589
 -- Function: demo_wavelets
     DEMO_WAVELETS  Wavelet filter banks
     
        This demo exemplifies the use of the wavelet filter bank trees. All 
        representations use "least asymmetric" Daubechies wavelet orthonormal
        filters 'sym8' (8-regular, length 16).
     
        Figure 1: DWT representation
     
           The filter bank tree consists of 11 levels of iterated 2-band basic
           wavelet filter bank, where only the low-pass output is further 
           decomposed. This results in 12 bands with octave resolution. 
     
        Figure 2: 8-band DWT representation
     
           The filter bank tree (effectively) consists of 3 levels of iterated
           8-band basic wavelet filter bank resulting in 22 bands. Only the
           low-pass output is decomposed at each level.
     
        Figure 3: Full Wavelet filter bank tree representation
     
           The filter bank tree depth is 8 and it is fully decomposed meaning
           both outputs (low-pass and high-pass) of the basic filter bank is
           plot further. This results in 256 bands linearly covering the 
           frequency axis.
     
        Figure 4: Full Wavelet filter bank tree representation
     
           The same case as before, but symmetric nearly orthogonal basic
           filter bank is used.
     
        Figure 5: Full Dual-tree Wavelet filter bank representation
     
           This is a 2 times redundant representation using Q-shift dual-tree
           wavelet filters.
     
     *Url*: <http://ltfat.github.io/doc/demos/demo_wavelets.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 35
DEMO_WAVELETS  Wavelet filter banks



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1724
 -- Function: demo_wfbt
     DEMO_WFBT  Auditory filterbanks built using filterbank tree structures
     
        This demo shows two specific constructions of wavelet filterbank trees
        using several M-band filterbanks with possibly different M (making the
        thee non-homogenous) in order to approximate auditory frequency bands 
        and a musical scale respectively.  Both wavelet trees produce perfectly
        reconstructable non-redundant representations. 
     
        The constructions are the following:
     
           1) Auditory filterbank, approximately dividing the frequency band 
              into intervals reminisent of the bask scale.
     
           2) Musical filterbank, approximately dividing the freq. band into
              intervals reminicent of the well-tempered musical scale.
              
        Shapes of the trees were taken from fig. 8 and fig. 9 from the refernece.
        Sampling frequency of the test signal is 48kHz as used in the article.
     
        Figure 1: Frequency responses of the auditory filterbank.
     
           Both axes are in logarithmic scale.
        
        Figure 2: TF plot of the test signal using the auditory filterbank.
      
        Figure 3: Frequency responses of the musical filterbank.
     
           Both axes are in logarithmic scale.
        
        Figure 4: TF plot of the test signal using the musical filterbank.
     
        References:
          F. Kurth and M. Clausen. Filter bank tree and M-band wavelet packet
          algorithms in audio signal processing. Signal Processing, IEEE
          Transactions on, 47(2):549--554, Feb 1999.
          
     *Url*: <http://ltfat.github.io/doc/demos/demo_wfbt.html>


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
DEMO_WFBT  Auditory filterbanks built using filterbank tree structures





