# doc-cache created by Octave 4.0.3
# name: cache
# type: cell
# rows: 3
# columns: 23
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
av_d2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1909
 -- Function File: OUTPUT = av_d2 (D2_C2D_C1_OUT)
 -- Function File: OUTPUT = av_d2 (D2_C2D_C1_OUT, PARAMNAME,
          PARAMVALUE, ...)
     This program takes the output of d2, c2d or c1 and smooths it by
     averaging over a given interval. It is also possible to specify
     the range of  embedding dimensions to be smoothed. This function
     makes most sense for the "d2" field of the d2 output or the output
     of c2d. By default it only smooths field "d2" of the d2 output.

     Assuming the two column vectors of a matrix (one of the fields of
     the input struct) are R and D then one of the output matrices will
     be of the form:

           _                              _
          |                  __ a          |
          |            1    \              |
          |   r    ,  ----   |       d     |
          |_   i      2a+1  /__ j=-a  i-j _|

     *Input*

     The input needs to be the output of d2, c2d or c1.

     *Parameters*

    MINDIM
          Minimum dimension to smooth, this also determines the size of
          the output struct [default = 1].

    MAXDIM
          Maximum dimension to smooth (also determines size of output
          struct) [default = 1].

    A
          Smooth over an interval of `2 * a + 1' points [default = 1].

     *Switch*

    SMOOTHALL
          This switch makes only works for inputs that were generated
          by d2.  If this switch is set all of the fields of the input
          are smoothed and not just field "d2".

     *Output*

     The output is a struct array, which is a subarray of the input.
     The indexes used to create the subarray are MINDIM:MAXDIM. Some or
     all of the fields of this output have been smoothed (depending on
     the SMOOTHALL switch).

     See also: demo av_d2, d2, c2t, c2g.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program takes the output of d2, c2d or c1 and smooths it by
averaging over 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2037
 -- Function File: OUTPUT = boxcount (S)
 -- Function File: OUTPUT = boxcount (S, PARAMNAME, PARAMVALUE, ...)
     Estimates the Renyi entropy of Qth order using a partition of the
     phase space instead of using the Grassberger-Procaccia scheme.

     The program also can handle multivariate data, so that the phase
     space is build of the components of the time series plus a
     temporal embedding, if desired. Also, note that the memory
     requirement does not increase exponentially like 1/epsilon^M but
     only like M*(length of series). So it can also be used for small
     epsilon and large M.  No finite sample corrections are implemented
     so far.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    M
          The maximum embedding dimension [default = 10].

    D
          The delay used [default = 1].

    Q
          Order of the entropy [default = 2.0].

    RLOW
          Minimum length scale [default = 1e-3].

    RHIGH
          Maximum length scale [default = 1].

    EPS_NO
          Number of length scale values [default = 20].

     *Output*

     The output is alligned with the input. If the input components
     where column vectors then the output is a
     maximum-embedding-dimension x number-of-components struct array
     with the following fields:
    DIM
          Holds the embedding dimension of the struct.

    ENTROPY
          The entropy output. Contains three columns which hold:
            1. epsilon

            2. Qth order entropy (Hq (dimension,epsilon))

            3. Qth order differential entropy (Hq (dimension,epsilon) -
               Hq (dimension-1,epsilon))

     See also: demo boxcount, d2, c1.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Estimates the Renyi entropy of Qth order using a partition of the phase
space in



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2103
 -- Function File: OUTPUT = c1 (S)
 -- Function File: OUTPUT = c1 (S, PARAMNAME, PARAMVALUE, ...)
     Computers curves for the fixed mass computation of information
     dimension (mentioned in TISEAN 3.0.1 documentation).

     A logarithmic range of masses between 1/N and 1 is realised by
     varying the neighbour order k as well as the subsequence length n.
     For a given mass k/n, n is chosen as small is possible as long as
     k is not smaller than the value specified by parameter K .

     You will probably use the auxiliary functions c2d or c2t to
     process the output further. The formula used for the Gaussian
     kernel correlation sum does not apply to the information dimension.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    MINDIM
          The minimum embedding dimension [default = 1].

    MAXDIM
          The maximum embedding dimension [default = 10].

    D
          The delay used [default = 1].

    T
          Minimum time separation [default = 0].

    N
          The number of reference points. That number of points are
          selected at random from all time indices [default = 100].

    RES
          Resolution, values per octave [default = 2].

    I
          Seed for the random numbers [use default seed].

    K
          Maximum number of neighbors [default = 100].

     *Switch*

    VERBOSE
          Display information about current mass during execution.

     *Output*

     The output is a MAXDIM - MINDIM + 1 x 1 struct array with the
     following fields:
    DIM
          The embedding dimension of the struct.

    C1
          A matrix with two collumns that contain the following data:
            1. radius

            2. 'mass'

     See also: demo c1, c2d, c2t.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Computers curves for the fixed mass computation of information dimension
(mentio



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 801
 -- Function File: OUTPUT = c2d (C1_OUT)
 -- Function File: OUTPUT = c2d (C1_OUT, IAV)
     This program calculates the local slopes by fitting straight lines
     onto c1 correlation sum data (the 'c1' field of the c1 output).

     *Inputs*

    C1_OUT
          The output of function c1.

    IAV
          Set what range the average should be calculated on (-IAV,
          ..., +IAV) [default = 1].

     *Output*

     The output is a struct array of the same length as the input.  It
     contains the following fiels:

    DIM
          The dimension for each matrix D.

    D
          Contains the local slopes of the logarithm of the correlation
          sum.

     See also: c1, d2.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program calculates the local slopes by fitting straight lines onto
c1 corre



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1320
 -- Function File: OUTPUT = c2g (D2_OUT)
     This program calculates the Gaussian kernel correlation integral
     and its logarithmic derivatice from correlation sums calculated by
     d2 (the 'c2' field of the d2 output).

     It uses the following formula to calculate the Gaussian kernel
     correlation integral:

                       /00            2
                   1   |        /    x   \
          C (r) = ---  | dx exp |- ----- | x C(x)
           G        2  |        \     2  /
                   r   /0           2r

     And the logarithmic derivative is calculated using:

                     d
          D (r) = ------- log C (r)
           G      d log r      G

     *Input*

     The input needs to be the output of d2.

     *Output*

     The output is a struct array of the same length as the input.  It
     contains the following fiels:

    DIM
          The dimension for each matrix G.

    G
          Matrix with three columns. The first contains epsilon (the
          first column of field 'c2' from the d2 output), the second is
          the Gaussian kernel correlation integral and the third its
          logarithmic derivative.

     See also: demo c2g, d2, c2t, av_d2.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program calculates the Gaussian kernel correlation integral and
its logarit



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1231
 -- Function File: OUTPUT = c2t (D2_C1_OUT)
     This program calculates the maximum likelihood estimator (the
     Takens' estimator) from correlation sums of the output of d2 (the
     'c2' field of the d2 output) or c1 (the 'c1' field of c1 output).

     The estimator is calculated using the following equation (the
     integral is computed for the discrete values of C(r) by assuming
     an exact power law between the available points):

                      C(r)
          D (r) = ------------
           T       /r    C(x)
                   |  dx ----
                   /0     x

     *Input*

     The input needs to be the output of d2 or c1.

     *Output*

     The output is a struct array of the same length as the input.  It
     contains the following fiels:

    DIM
          The dimension for each matrix T.

    T
          Matrix with two columns. The first contains epsilon (the
          first column of field 'c2' from d2 output or field 'c1' from
          c1 output) and the second is the maximum likelihood estimator
          (Takens' estimator).

     See also: demo c2t, d2, c1, c2g, av_d2.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program calculates the maximum likelihood estimator (the Takens'
estimator)



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3554
 -- Function File: [VALUES, PARS] = d2 (S)
 -- Function File: [VALUES, PARS] = d2 (S, PARAMNAME, PARAMVALUE, ...)
     This program estimates the correlation sum, the correlation
     dimension and the correlation entropy of a given, possibly
     multivariate, data set. It uses the box assisted search algorithm
     and is quite fast as long as one is not interested in large length
     scales. All length scales are computed simultaneously and the
     current center and epsilon are written every 2 min (real time, not
     cpu time) or every set number of center value increases.  It is
     possible to set a maximum number of pairs. If this number is
     reached for a given length scale, the length scale will no longer
     be treated for the rest of the estimate.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    M
          The maximum embedding dimension [default = 10].

    D
          The delay used [default = 1].

    T
          Theiler window [default = 0].

    RLOW
          Minimum length scale [default = 1e-3].

    RHIGH
          Maximum length scale [default = 1].

    EPS_NO
          Number of length scale values [default = 100].

    N
          Maximum number of pairs to be used (value 0 means all
          possible pairs) [default = 1000].

    P
          This parameter determines after how many iterations (center
          points) should the program pause and write out how many
          center points have been treated so far and the current
          epsilon. If PLOT_CORR or PLOT_SLOPES or PLOT_ENTROP is set
          then during the pause a plot of the current state of C2, D2
          or H2 (respectively) is produced. Regardless of the value of
          this parameter the program will pause every two minutes
          [default = only pause every 2 minutes].

     *Switches*

    NORMALIZED
          When this switch is set the program uses data normalized to
          [0,1] for all components.

    PLOT_CORR
          If this switch is set then whenever the execution is paused
          (the frequency can be set with parameter P) the most recent
          correlation sums are plotted. The color used for them is blue.

    PLOT_SLOPES
          Same as PLOT_CORR except the plotted values are the local
          slopes.  They are plotted in red.

    PLOT_ENTROP
          Same as PLOT_CORR except the correlation entropies are
          plotted.  They are plotted in green.

     *Output*

    VALUES
          This is a struct array that contains the following fields:
             * dim - the dimension of the data

             * c2 - the first column is the epsilon and the second the
               correlation sums for a particular embedding dimension

             * d2 - the first column is the epsilon and the second the
               local slopes of the logarithm of the corrlation sum

             * h2 - the first column is the epsilon and the second the
               correlation entropies

    PARS
          This is a struct. It contains the following fields:
             * treated - the number of center points treated

             * eps - the maximum epsilon used

     See also: demo d2, av_d2, c2t, c2g.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program estimates the correlation sum, the correlation dimension
and the co



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2138
 -- Function File: OUTPUT = delay (S)
 -- Function File: OUTPUT = delay (S, PARAMNAME, PARAMVALUE, ...)
     Produce delay vectors

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series. So

               S = [[1:1000];[5:1004]]
          would be considered a 2 component, 1000 element time series.
          Thus a typical call of 'henon' requires to choose one column
          of it. For instance:

               res = henon (5000);
               delay (res(:,1));

     *Parameters*

    D
          Delay of the embedding vector. Can be either a vector of
          delays or a single value. Replaces flags '-d' and '-D' from
          TISEAN package. Example

               delay ([1:10], 'd', [2,4], 'm', 3)
          This input will produce a delay vetor of the form

               (X(i),X(i-2),X(i-2-4))
          It is important to remember to keep (lenght of 'D') == (value
          of flag '-M' from TISEAN == number of components of (S))
          whenever parameter 'D' is a vector.

    F
          The format of the embedding vector. Replaces flag '-F' from
          TISEAN. Example (assuming A and B are column vectors of the
          same length)

               delay ([A,B], 'f', [3,2])
          This input will produce a delay vector in the form

               (A(i),A(i-1),A(i-2),B(i),B(i-1))

    M
          The embedding dimension. Replaces flag '-m' from TISEAN. Must
          be scalar integer. Also it needs to be integer multiple of
          number of components of (S) or else 'F' needs to be set. The
          following two examples are equivalent calls (A, B, C are
          column vectors of the same size)

               delay ([A,B,C], 'm', 9)
               delay ([A,B,C], 'f', [3,3,3])

     *Output*

     Produces a matrix that contains delay vectors.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Produce delay vectors



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 966
 -- Function File: OUTPUT_ARRAY = henon (L, ...)
 -- Function File: OUTPUT_ARRAY = henon (L, PARAMNAME, PARAMVALUE, ...)
     Generate Henon map

          x(n+1) = 1 - a * x(n) * x(n) + b * y(n)
          y(n+1) = x(n)

     *Input*

    L
          The number of points (x,y), must be integer. Required value.

     *Parameters*

    A
          Defines parameter 'a' (default=1.4)

    B
          Defines parameter 'b' (default=0.3)

    X
          Initial 'x' (default=0.68587)

    Y
          Initial 'y' (defaul=0.65876)

    NTRANS
          Defines number of transient points (default=10000), must be
          positive integer scalar

     *Output*

     OUTPUT_ARRAY is of length L. It contains points on the Henon Map.

     *Usage example*

     `out = henon(1000, "a", 1.25)'

     After this command OUT will be a 1000x2 matrix with Henon map
     points as rows. It will generate 1000 points.

     *Algorithm*
     On basis of TISEAN package henon


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
Generate Henon map



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1288
 -- Function File: OUTPUT_ARRAY = ikeda (L, ...)
 -- Function File: OUTPUT_ARRAY = ikeda (L, PARAMNAME, PARAMVALUE, ...)
     Generate Ikeda map

                                                b*i
          z(n+1) = 1 + c * z(n) * exp (a*i - ---------)
                                             1+|z(n)|

     *Input*

    L
          The number of points (x,y), must be integer. Required value.

     *Parameters*

    A
          Defines parameter 'a' (default=0.4)

    B
          Defines parameter 'b' (default=6.0)

    C
          Defines parameter 'c' (default=0.9)

    R
          Initial real value of 'z' (default=0.68587)

    I
          Initial imaginary value of 'z' (defaul=0.65876)

    NTRANS
          Defines number of transient points (default=10000), must be
          positive integer scalar

     *Output*

     OUTPUT is of length L. The first columns are the real values of
     the Ikeda Map and the second are the imaginary values of the Ikeda
     map.  This is done to be work the same way that 'ikeda' in TISEAN
     works.

     *Usage example*

     `out = ikeda(1000, "a", 1.25)'

     After this command OUT will be a 1000x2 matrix with Henon map
     points as rows. It will generate 1000 points.

     *Algorithm* On basis of TISEAN package ikeda


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
Generate Ikeda map



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1803
 -- Function File: OUTPUT = lfo_run (S)
 -- Function File: OUTPUT = lfo_run (S, PARAMNAME, PARAMVALUE, ...)
     This function depending on whether switch 'zeroth' is set produces
     either a local linear ansatz or a zeroth order ansatz for a
     possibly multivariate time series and iterates an artificial
     trajectory. The initial values for the trajectory are the last
     points of the original time series.  Thus it actually forecasts
     the time series.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    M
          The embedding dimension used. It is synonymous to the second
          part of flag '-m' from TISEAN. The first part of the TISEAN
          flag is omitted as all of the available components of S are
          analyzed [default = 1].

    D
          Delay used for the embedding [default = 1].

    L
          Number of iterations into the future, length of prediction
          [default = 1000].

    K
          Minimal number of neighbors for the fit [default = 30].

    R
          Neighborhood size to start with [default = 1e-3].

    F
          Factor to increase neighborhood size if not enough neighbors
          were found [default = 1.2].

     *Switch*

    ZEROTH
          Perform a zeroth order fit instead a local linear one. This
          is synonymous with flag '-0' from TISEAN.

     *Output*

     Components of the forecasted time series.

     See also: lfo_test, lfo_ar, lzo_run.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This function depending on whether switch 'zeroth' is set produces
either a loca



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1814
 -- Function File: OUTPUT = lyap_k (X)
 -- Function File: OUTPUT = lyap_k (X, PARAMNAME, PARAMVALUE, ...)
     Estimates the maximum Lyapunov exponent using the algorithm
     described by Kantz on the TISEAN reference page:

     http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/chaospaper/citation.html

     *Input*

    X
          Must be realvector.

     *Parameters*

    MMAX
          Maximum embedding dimension to use [default = 2].

    MMIN
          Minimum embedding dimension to use [default = 2].

    D
          Delay used [default = 1].

    RLOW
          Minimum length scale to search neighbors [default = 1e-3].

    RHIGH
          Maximum length scale to search neighbors [default = 1e-2].

    ECOUNT
          Number of length scales to use [default = 5].

    N
          Reference points to use [all].

    S
          Number of iterations in time [default = 50].

    T
          'theiler window' [default = 0].

     *Switch*

    VERBOSE
          Prints information about the current length scale at runtime.

     *Output*

     The output is a struct array of size:

     `'ecount' x ('mmax' - 'mmin' + 1)'

     It has the following fields:
        * `eps' - holds the epsilon for the exponent

        * `dim' - holds the embedding dimension used in exponent

        * `exp' - contains the exponent data. It consists of 3 columns:
            1. The number of the iteration

            2. The logarithm of the stretching factor (the slope is the
               Laypunov exponent if it is a straight line)

            3. The number of points for which a neighborhood with
               enough points was found

     See also: demo lyap_k, lyap_r, lyap_spec.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Estimates the maximum Lyapunov exponent using the algorithm described by
Kantz o



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1356
 -- Function File: OUTPUT = lyap_r (X)
 -- Function File: OUTPUT = lyap_r (X, PARAMNAME, PARAMVALUE, ...)
     Estimates the largest Lyapunov exponent of a given scalar data set
     using the algorithm described by Resentein et al. on the TISEAN
     refernce page:

     http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/chaospaper/citation.html

     *Input*

    X
          Must be realvector. The output will be alligned with the
          input.

     *Parameters*

    M
          Embedding dimension to use [default = 2].

    D
          Delay used [default = 1].

    T
          Window around the reference point which should be omitted
          [default = 0].

    R
          Minimum length scale for the neighborhood search [default =
          1e-3].

    S
          Number of iterations in time [default = 10].

     *Switch*

    VERBOSE
          Gives information about the current epsilon while performing
          computation.

     *Output*

     Alligned with input. If input was a column vector than output
     contains two columns. The first contains the iteration number and
     the second contains the logarithm of the stretching factor for that
     iteration.

     See also: demo lyap_r, lyap_k, lyap_spec.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Estimates the largest Lyapunov exponent of a given scalar data set using
the alg



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2618
 -- Function File: [LYAP_EXP, PARS] = lyap_spec (S)
 -- Function File: [LYAP_EXP, PARS] = lyap_spec (S, PARAMNAME,
          PARAMVALUE, ...)
     Estimates the spectrum of Lyapunov exponents using the method of
     Sano and Sawada.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    M
          Embedding dimension [default = 2].

    D
          Currently unused, will be delay used in future.

    N
          Number of iterations [default = length (S)].

    R
          Minimum neighborhood size [default = 1e-3].

    F
          Factor to increase the size of the neighborhood if the
          program didn't find enough neighbors [default = 1.2].

    K
          Number of neighbors to use (this implementation uses exactly
          the number of neighbors specified, if more are found only the
          K nearest are used) [default = 30].

    P
          Specify after how many iteration should the current output be
          displayed. This is useful for data sets that can take a long
          time.  Also, if the program runs longer than 10 seconds it
          will display the current state, regardless [default =
          calculate all of the data at once and don't intermediary
          steps].

     *Switch*

    INVERT
          Inverts the order of the time series. Can help finding
          spurious exponents.

     *Output*

     The output is alligned with the components of the input.
    LYAP_EXP
          Assuming an input with column vectors this part of the output
          will consist of `columns (S) * m + 1' columns (the 'm' stands
          for the embedding dimension). The first column will be the
          iteration number and rest contain estimates of the Lyapunov
          exponents in decreasing order.

    PARS
          This is a struct that contains the following parameters
          associated with the calculated Lyapunov exponents:
             * rel_err - the relative error for every dimension of the
               input

             * abs_err - the absolute error for every dimension of the
               input

             * nsize - average neighborhood size

             * nno - average number of neighbors

             * ky_dim - estimated KY-Dimension

     See also: lyap_k, lyap_r.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Estimates the spectrum of Lyapunov exponents using the method of Sano
and Sawada



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2105
 -- Function File: OUTPUT = lzo_run (S)
 -- Function File: OUTPUT = lzo_run (S, PARAMNAME, PARAMVALUE, ...)
     This program fits a locally zeroth order model to a possibly
     multivariate time series and iterates the time series into the
     future. The existing data set is extended starting with the last
     point in time. It is possible to add gaussian white dynamical
     noise during the iteration.

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

     *Parameters*

    M
          The embedding dimension used. It is synonymous to the second
          part of flag '-m' from TISEAN. The first part of the TISEAN
          flag is omitted as all of the available components of S are
          analyzed [default = 1].

    D
          Delay used for the embedding [default = 1].

    L
          Number of iterations into the future [default = 1000].

    K
          Minimal number of neighbors for the fit [default = 50].

    DNOISE
          Add dynamical noise as percentage of the variance, this value
          is given in percentage. The same as flag '-%' from TISEAN
          [default = no noise (0)].

    I
          Seed for the random number generator used to add noise. If
          set to 0 the time command is used to create a seed [default =
          0x9074325].

    R
          Neighborhood size to start with [default = 1e-3].

    F
          Factor to increase neighborhood size if not enough neighbors
          were found [default = 1.2].

     *Switch*

    ONLYNEAREST
          If this switch is set then the program uses only the nearest K
          neighbor found. This is synonymous with flag '-K' from TISEAN.

     *Output*

     Components of the forecasted time series.

     See also: demo lzo_run, lzo_test, lzo_gm.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
This program fits a locally zeroth order model to a possibly
multivariate time s



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1426
 -- Function File: [PARS, FORECAST] = rbf (X)
 -- Function File: [PARS, FORECAST] = rbf (X, PARAMNAME, PARAMVALUE,
          ...)
     Models the data making a polynomial ansatz.

     *Input*

    X
          Must be realvector. The output will be alligned with the
          input.

     *Parameters*

    M
          The embedding dimension. Synonymous with flag '-m' from TISEAN
          [default = 2].

    D
          Delay used for embedding [default = 1].

    P
          Order of the polynomial [default = 2].

    N
          Number of points for the fit. The other points are used to
          estimate the out of sample error [default = length (X)].

    L
          The length of the predicted series [default = 0].

     *Output*

    PARS
          This structure contains parameters used for the fit. It has
          the following fields:
             * free - contains the number of free parameters of the fit

             * norm - contains the norm used for the fit

             * coeffs - contains the coefficients used for the fit

             * err - err(1) is the in sample error, and err(2) is the
               out of sample error (if it exists)

    FORECAST
          Contains the forecasted points. It's length is equal to the
          value of parameter L

     See also: demo polynom.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
Models the data making a polynomial ansatz.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2330
 -- Function File: [PAR, FORECAST] = rbf (X)
 -- Function File: [PAR, FORECAST] = rbf (X, PARAMNAME, PARAMVALUE, ...)
     This program models the data using a radial basis function (rbf)
     ansatz.  The basis functions used are gaussians, with center
     points chosen to be data from the time series. If the 'DriftOff'
     switch is not set, a kind of Coulomb force is applied to them to
     let them drift a bit in order to distribute them more uniformly.
     The variance of the gaussians is set to the average distance
     between the centers.  This program either tests the ansatz by
     calculating the average forecast error of the model, or makes a
     i-step prediction using the -L flag, additionally. The ansatz made
     is:

          x_n+1 = a_0 SUM a_i * f_i(x_n)

     where x_n is the nth delay vector and f_i is a gaussian centered
     at the ith center point.

     *Input*

    X
          Must be realvector. The output will be alligned with the
          input.

     *Parameters*

    M
          The embedding dimension. Synonymous with flag '-m' from TISEAN
          [default = 2].

    D
          Delay used for embedding [default = 1].

    P
          Number of centers [default = 10].

    S
          Steps to forecast (for the forecast error) [default = 1].

    N
          Number of points for the fit. The other points are used to
          estimate the out of sample error [default = length (X)].

    L
          Determines the length of the predicted series [default = 0].

     *Switch*

    DRIFTOFF
          Deactivates the drift (Coulomb force), which is otherwise on.

     *Output*

    PARS
          This structure contains parameters used for the fit. It has
          the following fields:
             * centers - contains coordinates of the center points

             * var - variance used for the gaussians

             * coeffs - contains the coefficients (weights) of the
               basis functions used for the model

             * err - err(1) is the in sample error, and err(2) is the
               out of sample error (if it exists)

    FORECAST
          Contains the forecasted points. It's length is equal to the
          value of parameter L

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
This program models the data using a radial basis function (rbf) ansatz.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 -- Function File: [FREQS, SPEC] = spectrum (X)
 -- Function File: [FREQS, SPEC] = spectrum (X, PARAMNAME, PARAMVALUE,
          ...)
     Produce delay vectors

     *Input*

    X
          Must be realvector. The spectrum will be performed on it.

     *Parameters*

    F
          Frequency sampling rate in Hz [default = 1]

    W
          Frequency resolution in Hz [default = f / length (X)]

     *Output*

    FREQS
          The frequencies for the spectrum of vector X

    SPEC
          The spectrum of the input vector X

     *Example of Usage*


          spectrum (data_vector, 'f', 10, 'w', 0.001)

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
Produce delay vectors



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1470
 -- Function File: output = spikeauto (X, BIN, BINTOT)
 -- Function File: output = spikeauto (..., 'INTER')
     Computes the binned autocorrelation function of a series of event
     times.

     The data is assumed to represent a sum of delta functions centered
     at the times given. The autocorrelation function is then a double
     sum of delta functions which must be binned to be representable.
     Therfore, you have to choose the duration of a single bin (with
     argument BIN) and the maximum time lag (argument BINTOT)
     considered.

     *Inputs*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

    BIN
          The duration of a single bin.

    BINTOT
          The maximum lag considered.

     *Switch*

    INTER
          Treat the input as inter-event intervals instead of the time
          at which the event occured.

     *Output*

     The output is alligned with the input. If the input was a column
     vector the output will consist of two columns, the first holds
     information about which bin did the autocorellation fit into, and
     the second the number of autocorellations that fit into that bin.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
Computes the binned autocorrelation function of a series of event times.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1196
 -- Function File: OUTPUT = timerev (S)
 -- Function File: OUTPUT = timerev (S, DELAY)
     Calculates time reversal assymetry statistic.

     Accomplishes this using the following equation applied to each
     component separately:

                          3
           sum (y  - y   )
                 n    n-d
          ------------------
                          2
           sum (y  - y   )
                 n    n-d

     *Input*

    S
          This function always assumes that each time series is along
          the longer dimension of matrix S. It also assumes that every
          dimension (counting along the shorter dimension) of S is
          considered a component of the time series.

    DELAY
          The delay for the statistic ('d' in the equation above)
          [default = 1].

     *Output*

     The output is the calculated time reversal asymmetry statistic. It
     is calculated for each component separately and is alligned with
     the components, so if the input's components were columns vectors
     the output will be a row vector and vice versa.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 45
Calculates time reversal assymetry statistic.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2506
 -- Function File: [OLENS, ORBIT_DATA, ACC, STAB] = upo (X, M)
 -- Function File: ... = upo (X, M, PARAMNAME, PARAMVALUE, ...)
     Locates unstable periodic points.

     Note: This function provides a wrapper for the original upo from
     TISEAN. The documentation to TISEAN states that upo has not been
     tested thoroughly and therefore might contain errors. Since this
     function only provides a wrapper for the TISEAN upo any such
     errors will be inherited. For more information consult the TISEAN
     documentation:
     http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/docs_f/upo.html

     *Inputs*

    X
          Must be realvector. If it is a row vector then the output will
          be row vectors as well. Maximum length is 1e6. This
          constraint existed in the TISEAN program and therefore it is
          inherited. This should not be a problem as this program takes
          9 seconds for a 10000 element long noisy henon series.

    M
          Embedding dimension. Must be scalar positive integer.

     *Parameters*

     Either R or V must be set and at least one must be different from
     zero.
    R
          Absolute kernel bandwidth. Must be a scalar.

    V
          Same as fraction of standard deviation.

    MTP
          Minimum separation of trial points [default = value of 'r' OR
          std(data) * value of 'v'].

    MDO
          Minimum separation of distinct orbits [default = value of 'r'
          OR std(data) * value of 'v'].

    S
          Initial separation for stability [default = value of 'r' OR
          std(data) * value of 'v'].

    A
          Maximum error of orbit to be plotted [default = all plotted].

    P
          Period of orbit [default = 1].

    N
          Number of trials [default = numel (X)].

     *Outputs*

    OLENS
          A vector that contains the period lengths (sizes) for each
          orbit.

    ORBIT_DATA
          A vector that contains all of the orbit data. To find data
          for the n-the orbit you need to:

               nth_orbit_data = orbit_data(sum(olens(1:n-1)).+(1:olens(n)));

    ACC
          A vector that contains the accuracy of each orbit.

    STAB
          A vector that contains the stability of each orbit.
     Note that

     `length (olens) == length (acc) == length (stab) #== number of
     orbits'.

     See also: demo upo, upoembed.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 33
Locates unstable periodic points.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 965
 -- Function File: OUTPUT = upoembed (OLENS,ORBIT_DATA, DELAY)
 -- Function File: OUTPUT = upoembed (OLENS,ORBIT_DATA, DELAY,
          PARAMNAME, PARAMVALUE, ...)
     Creates delay coordinates for upo output.

     *Inputs*

    OLENS
          This vector contains the periods that are generated by upo.

    ORBIT_DATA
          The orbit data that is generated by upo.

    DELAY
          The delay used to get the delay coordinates.

     *Parameter*
    M
          The embedding dimension used [default = 2].

    P
          The period of the orbit to be extracted. This may be a vector
          [default = extract all orbit periods].

     *Output*

     A cell that contains the delay vectors for each orbit. The orbits
     are in the same order as they are in OLENS. Can be converted to
     matrix using `str2mat (output)'.

     See also: upo.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Creates delay coordinates for upo output.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1580
 -- Function File: output = xzero (X1, X2)
 -- Function File: output = xzero (X1, X2, PARAMNAME, PARAMVALUE, ...)
     Takes two data sets and fits a zeroth order model of data set 1
     (X1) to predict data set 2 (X2) - cross prediction. It then
     computes the error of the model. This is done by searching for all
     neighbors in X1 of the points of set X2 which should be forecasted
     and taking as their images the average of the images of the
     neighbors. The obtained forecast error is normalized to the
     variance of data set X2.

     *Inputs*

     Both X1 and X2 must be present. They must be realvectors of the
     same length.

     *Parameters*

    M
          Embedding dimension [default = 3].

    D
          Delay for embedding [default = 1].

    N
          The number of points for which the error should be calculated
          [default = all].

    K
          Minimum number of neighbors for the fit [default = 30].

    R
          The neighborhood size to start with [default = 1e-3].

    F
          Factor by which to increase the neighborhood size if not
          enough neighbors were found [default = 1.2].

    S
          Steps to be forecast (`x2(n+steps) = av(x1(i+steps)')
          [default = 1].

     *Output*

     Contains value of parameter 'S' lines. Each line represents the
     forecast error divided by the standard deviation of the second
     data set (X2). This second data set is the one being forecasted.

     *Algorithms*

     The algorithms for this functions have been taken from the TISEAN
     package.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Takes two data sets and fits a zeroth order model of data set 1 (X1) to
predict 





