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


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



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


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



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


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



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


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



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


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



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


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



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2141
 -- 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: 8
endtoend


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2729
 -- Function File: OUTPUT = endtoend (S)
 -- Function File: OUTPUT = endtoend (..., 'verbose', ...)
 -- Function File: OUTPUT = endtoend (..., WEIGTH_JUMP, ...)

     Determine the effect of an end-to-end mismatch on the autocorrelation
     structure for various sub-sequence lengths.

     It is important to avoid jumps and phase slips that occur when the data is
     periodically continued when making Fourier based surrogates, e.g.  with
     surrogates.

     The mismatch in value is measured by:
                    /           \ 2
                    | x(1)-x(N) |
                    \           /
          d     = __________________
           jump     __
                   \   /      _ \ 2
                    |  | x(n)-x |
                   /__ \        /

     And the phase slip by:
                   /                           \ 2
                   | (x(2)-x(1))-(x(N)-x(N-1)) |
                   \                           /
          d     = _________________________________
           slip        __
                      \   /      _ \ 2
                       |  | x(n)-x |
                      /__ \        /

     The weighted mismatch is then:
                weight*d     + (1-weight)*d
                        jump               slip

     In the multivariate case, the values are computed for each channel
     separately and then averaged.

     *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.
     WEIGHT_JUMP
          The weight used [default = 0.5].

     *Switch*

     VERBOSE
          If this switch is set the output will be displayed on the screen in
          readible format.

     *Output*

     OUTPUT
          The output is a struct array that contains the following fields:
             • length - the length of the series used in calculating the
               mismatch
             • offset - the offset (counting from the first element) of the
               subseries used to calculate the mismatch
             • lost - percent of the of the original series that was lost (not
               used)
             • jump - the mismatch in value (given as percentage)
             • slip - the phase slip (given as percentage)
             • weigthed - the weigthed mismatch (given as percentage)
          Each consecutive structure in this array has an increasingly lower
          weighted mismatch

     See also: surrogates.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Determine the effect of an end-to-end mismatch on the autocorrelation structu...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1913
 -- Function File: [DIM, FRAC, AVGSIZE, AVGSRTSIZE] = false_nearest (S)
 -- Function File: ... = false_nearest (S, PARAMNAME, PARAMVALUE, ...)

     Determines the fraction of false nearest neighbors.

     *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.

     *Parameters*

     MINEMB
          This is the flag '-m' from TISEAN. It is the minimal embedding
          dimensions of the vectors [default = 1].
     MAXEMB
          This parameter is consistent with the second part of the flag '-M'
          from TISEAN. The first part of that flag is unnecessary as this
          function assumes that all components of the input data are used.  This
          parameter determines the maximum embedding dimension of the vectors
          [default = 5].
     D
          The delay of the vectors [default = 1].
     T
          The theiler window [default = 0].
     F
          Ratio factor [default = 2.0].

     *Switches*

     VERBOSE
          If this switch is selected the function will give progress reports
          along the way.

     *Outputs*

     DIM
          This holds the dimension of the output data.
     FRAC
          The fraction of false nearest neighbors.
     AVGSIZE
          The average size of the neighborhood.
     AVGRTSIZE
          The average of the squared size of the neighborhood.

     See also:
     http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/docs_c/false_nearest.html
     or demo for more information.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Determines the fraction of false nearest neighbors.



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


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

     Multivariate noise reduction using the GHKSS algorithm.

     *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
          The delay for the embedding [default = 1].
     Q
          Dimension of the manifold to project to [default = 2].
     K
          Minimal number of neighbours [default = 50].
     R
          Minimal size of neighbourhood [default = 1/1000].
     I
          Number of iterations [default = 1].

     *Switches*

     EUCLIDEAN
          When this switch is selected the function will use the euclidean
          metric instead of the tricky one.
     VERBOSE
          If this switch is selected the function will give progress reports
          along the way.  Those include the average correction, trend and how
          many points were corrected for which epsilon.

     *Output*

     The OUTPUT contains the cleaned time series.  The output is of the same
     size as the input.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Multivariate noise reduction using the GHKSS algorithm.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 976
 -- 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: 1293
 -- 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: 6
lfo_ar


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

     This program makes a local linear ansatz and estimates the one step
     prediction error of the model.  The difference to lfo-test is that it does
     it as a function of the neighborhood size.  The name "lzo_ar" means 'local
     first order -> AR-model'.

     *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].
     I
          For how many points should the error be calculated [default = length
          (S)].
     RLOW
          The neighborhood size to start with [default = 1e-3].
     RHIGH
          The neighborhood size to end with [default = 1].
     F
          Factor to increase neighborhood size if not enough neighbors were
          found [default = 1.2].
     S
          Steps to be forecast ‘x(n+s) = f(x(n))’ [default = 1].
     C
          Width of causality window [default = value of parameter S]

     *Output*

     The output is alligned with the input.  If the components of the input(S)
     were column vectors then the number of columns of the output is 4 + number
     of components of S.  In this case the output will have the following values
     in each row:
        • Neighborhood size (units of data)
        • Relative forecast error ((forecast error)/(variance of data))
        • Relative forecast error for the individual components of the input,
          this will take as many columns as the input has
        • Fraction of points for which neighbors were found for this
          neighborhood size
        • Average number of neighbors found per point

     See also: demo lfo_ar, lfo_test, lfo_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 program makes a local linear ansatz and estimates the one step predictio...



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2474
 -- Function File: [REL, IND] = lfo_test (S)
 -- Function File: [REL, IND] = lfo_test (S, PARAMNAME, PARAMVALUE, ...)

     Makes a local linear ansatz and estimates the one step prediction error of
     the model.  It allows to determine the optimal set of parameters for the
     program lfo-run, which iterates the local linear model to get a clean
     trajectory.  The given forecast error is normalized to the variance of the
     data.

     *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].
     N
          Sets for how many points the error should be calculated [default is
          for all of the points].
     K
          Minimum number of neighbors for the fit [default = 30].
     R
          Size of neighbourhood to start with [default = 1/1000].
     F
          Factor to increase the neighbourhood size if not enough naighbors were
          found [default = 1.2].
     S
          Steps to be forecast ‘x(n+s) = f(x(n))’ [default = 1].
     C
          Width of causality window [default = value of parameter 'S'].

     *Outputs*

     REL
          This is a matrix of length equal to the parameter 'S'.  It contains
          the relative forecast error.  The first column (row depending on the
          input) contains the steps forecasted.  Relative means that the
          forecast error is divided by the standard deviation of the vector
          component.  Note: This does output is different than that of lzo_test.
          Here it gives relative forecast error for each component globally, not
          for each forecasted datapoint of each component.
     IND
          This is a matrix that contais the individual forecast error for each
          comonent of each reference point.  This is the same as passing '-V2'
          to TISEAN lfo-test.

     See also: lfo_ar, lfo_run.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Makes a local linear ansatz and estimates the one step prediction error of th...



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


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



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


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



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


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



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


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

     Estimates the average forecast error for a local constant (zeroth order)
     fit as a function of the neighborhood size.  The name "lzo_gm" means 'local
     zeroth order -> global mean'.

     *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].
     I
          For how many points should the error be calculated [default = length
          (S)].
     RLOW
          The neighborhood size to start with [default = 1e-3].
     RHIGH
          The neighborhood size to end with [default = 1].
     F
          Factor to increase neighborhood size if not enough neighbors were
          found [default = 1.2].
     S
          Steps to be forecast ‘x(n+s) = f(x(n))’ [default = 1].
     C
          Width of causality window [default = value of parameter S]

     *Output*

     The output is alligned with the input.  If the components of the input(S)
     were column vectors then the number of columns of the output is 4 + number
     of components of S.  In this case the output will have the following values
     in each row:
        • Neighborhood size (units of data)
        • Relative forecast error ((forecast error)/(variance of data))
        • Relative forecast error for the individual components of the input,
          this will take as many columns as the input has
        • Fraction of points for which neighbors were found for this
          neighborhood size
        • Average number of neighbors found per point

     See also: lzo_test, 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
Estimates the average forecast error for a local constant (zeroth order) fit ...



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2334
 -- Function File: [REL, IND] = lzo_test (S)
 -- Function File: [REL, IND] = lzo_test (S, PARAMNAME, PARAMVALUE, ...)

     Estimates the average forecast error for a zeroth order fit from a
     multidimensional 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].
     N
          Sets for how many points the error should be calculated [default is
          for all of the points].
     TDIST
          Temporal distance between the reference points [default = 1].
     K
          Minimum number of neighbors for the fit [default = 30].
     R
          Size of neighbourhood to start with [default = 1/1000].
     F
          Factor to increase the neighbourhood size if not enough naighbors were
          found [default = 1.2].
     S
          Steps to be forecast ‘x(n+s) = f(x(n))’ [default = 1].
     C
          Width of causality window [default = value of parameter 'S'].

     *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.

     *Outputs*

     REL
          This is a matrix of length equal to the parameter 'S'.  It contains
          the relative forecast error.  The first column (row depending on the
          input) contains the steps forecasted.  Relative means that the
          forecast error is divided by the standard deviation of the vector
          component.
     IND
          This is a matrix that contais the individual forecast error for each
          comonent of each reference point.  This is the same as passing '-V2'
          to TISEAN lzo-test.

     See also: demo lzo_test, lzo_gm, 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
Estimates the average forecast error for a zeroth order fit from a
multidimen...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2147
 -- Function File: EIGVAL = pca (S)
 -- Function File: [EIGVAL, EIGVEC] = pca (S)
 -- Function File: [EIGVAL, EIGVEC, TS] = pca (S)
 -- Function File: [...] = pca (S, PARAMNAME, PARAMVALUE, ...)

     Performs a global principal component analysis (PCA). It gives the
     eigenvalues of the covariance matrix and depending on the flag W settings
     the eigenvectors, projections of the input 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
          Defines embedding dimension.  Since all of the data in S is analysed
          there is no need for setting the number of columns to be read (as is
          the case in TISEAN 'pca') [default = 1].
     D
          Delay must be scalar integer [default = 1].
     Q
          Determines the properties of TS.  When parameter W is set then Q
          determines the projection dimension.  Otherwise it determines the
          number of components written to output [default = full dimension/all
          components].

     *Switch*

     W
          If W is set then TS is a projection of the time series onto the first
          Q eigenvectors (global noise reduction).  If W is not set then TS is a
          transformation of the time series onto the eigenvector basis.  The
          number of projection dimension/components printed is determined by
          parameter Q.

     *Output*

     EIGVAL
          The calculated eigenvalues.
     EIGVEC
          The eigenvectors.  The vectors are alligned with the longer dimension
          of S.
     TS
          If W is set then this variable holds the projected time series onto
          the first Q eigenvectors.  If W is not set then TS is the transformed
          time series onto the eigenvector basis (number of components ==
          parameter Q).

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Performs a global principal component analysis (PCA).



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1332
 -- Function File: OUTPUT = poincare (X)
 -- Function File: OUTPUT = poincare (X, M, PARAMNAME, PARAMVALUE, ...)
 -- Function File: OUTPUT = poincare (..., 'FromAbove', ...)

     Make a Poincare section for time continuous scalar data sets along one of
     the coordinates of the embedding vector.

     *Input*

     X
          Must be realvector.  If it is a row vector then the output will be a
          matrix that consists of row vectors as well.

     *Parameters*

     M
          The embedding dimension used.  It is synonymous to flag '-m' from
          TISEAN [default = 2].
     D
          Delay used for the embedding [default = 1].
     Q
          Component for the crossing [default = value of parameter 'm' (last
          one)].
     A

     *Switch*

     FROMABOVE
          If this switch is set the crossing will occur from above, instead of
          from below.  This is equivalent to setting flag '-C1' from TISEAN.

     *Output*

     The output consists of the as many components as the value of parameter M
     (columns or rows depending on input).  The first ‘M-1’ are the coordinates
     of the vector at the crossing and the last component is the time between
     the last two crossings.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Make a Poincare section for time continuous scalar data sets along one of the...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1415
 -- 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: 2322
 -- 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: 712
 -- 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: 1462
 -- 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: 9
spikespec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2252
 -- Function File: output = spikespec (X)
 -- Function File: output = spikespec (X, PARAMNAME, PARAMVALUE, ...)

     Computes a power spectrum assuming that the data are the times of singular
     events, e.g.  heart beats.

     These events do not need to be in ascending order.  Furthermore, the input
     can be treated as inter-event intervals rather than time if switch INTER is
     set.

     If the event times are ‘t(n), n=1,...,l’ the spectrum is defined by

                      l                    2
                   | ---                  |
                   | \     -i 2 pi f t(n) |
            S(f) = |  |  e                |
                   | /                    |
                   | ---                  |
                     n=1

     that is, the signal is taken to be a sum of delta functions at ‘t(n)’.
     ‘S(f)’ is computed for parameter F_NO frequencies between 0 and value of
     parameter F.  The result is binned down to a frequency resolution defined
     by parameter W.

     *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*

     F
          The maximum frequency [default = 2 * length (X) / total time].
     F_NO
          Number of frequencies [default = F * total time / 2].
     W
          Frequency resolution [defualt = 0 - return all frequencies].

     *Switch*

     INTER
          Treat the input as inter-event intervals instead of the time at which
          the event occured.
     VERBOSE
          Write to standard output the value of the 'total time', number of
          frequencies used, the maximum frequency and how many frequencies are
          binned.

     *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 the frequencies to
     which the spectrum was binned and the second holds the calculated spectrum
     value.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Computes a power spectrum assuming that the data are the times of singular
ev...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2732
 -- Function File: [SURRO_DATA, PARS] = surrogates (S)
 -- Function File: [SURRO_DATA, PARS] = surrogates (S, PARAMNAME, PARAMVALUE,
          ...)

     Generates multivariate surrogate data (implements the iterative Fourier
     scheme).  Surrogate data is generated from a dataset with the aim of
     testing whether the dataset was generated by a given process (null
     hypothesis).  The Fourier scheme assumes that the dataset is the output of
     a Gaussian linear stochastic process.  Surrogate data is generally used to
     test the null hypothesis.

     *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.  It's length must be factorizable by only 2, 3 and 5.  If
          not the largest submatrix that fulfills this requirement will be used.
          The function ‘endtoend’ can be used to determine what is the best
          submatrix for the data and then sending only that submatrix to this
          program.  Padding with zeros is *not* and option.

     *Parameters*

     N
          Sets the number of surrogates to be calculated.  Determines the form
          of the output (see Output section) [default = 1].
     I
          The maximum number of permutations.  Value '0' yields random
          permutations or if switch EXACT is set an unrescaled FFT surrogate.
          Value '1' is a surrogate close to the result of the AAFT procedure,
          but not quite the same.  Value '-1' means the program will perform
          iterations until there is no change between them [default = -1].
     SEED
          Set the seed for the random generator [default = use default seed].

     *Switch*

     EXACT
          This switch makes the spectrum of the output exact rather than a
          distribution.

     *Outputs*

     SURRO_DATA
          If parameter ‘n == 1’ then this is a matrix that holds the surrogate
          data.  If parameter ‘n > 1’ then it is N x 1 cell array of matrixes
          with the data.  In both cases the matrixes themselves are alligned
          with the input.
     PARS
          This is a matrix of size N x 2 (if the input components were column
          vectors, otherwise transposed).  The first column contains the number
          of iteration it took to generate the I-th surrogate, whereas the
          second column is the relative discrepency for the I-th surrogate.

     See also: demo surrogates, endtoend.

     *Algorithms*

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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Generates multivariate surrogate data (implements the iterative Fourier schem...



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1185
 -- 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: 2494
 -- 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: 970
 -- 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: 1572
 -- 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 predi...





