/usr/share/octave/packages/tisean-0.2.3/doc-cache

# doc-cache created by Octave 4.2.1
# 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: 1915
 -- 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: 2038
 -- 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: 2110
 -- 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: 804
 -- 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: 1323
 -- 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: 1234
 -- 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: 3573
 -- 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: 2158
 -- 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: 2732
 -- 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
structure 



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1918
 -- 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: 1636
 -- 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: 972
 -- 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: 1294
 -- 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: 2328
 -- 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
prediction e



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


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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2495
 -- 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 the m



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1815
 -- 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: 1364
 -- 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: 2623
 -- 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: 6
lzo_gm


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



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


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


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



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1432
 -- 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: 2335
 -- 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: 728
 -- 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: 1476
 -- 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: 2246
 -- 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 event



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


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



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1200
 -- 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: 2520
 -- 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: 971
 -- 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: 1588
 -- 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
octave-tisean 0.2.3-3 / usr / share / octave / packages / tisean-0.2.3 / doc-cache
