Description of the program: false_nearest
This program looks for the nearest neighbors of all data points in m
dimensions and iterates these neighbors one step (more precisely delay
steps) into the future. If
the ratio of the distance of the iteration and that of the
nearest neighbor exceeds a given threshold the point is marked as a
wrong neighbor. The output is the fraction of false neighbors for the
specified embedding dimensions (see
Kennel et al.).
Note:
We implemented a new second criterion.
If the distance to the nearest neighbor becomes smaller than the
standard deviation of the data devided by the threshold, the point is
omitted. This turns out to be a stricter criterion, but can show the
effect that for increasing embedding dimensions the number of points
which enter the statistics is so small, that the whole statistics is
meanlingless. Be aware of this!
Usage:
false_nearest [Options]
Everything not being a valid option will be interpreted as a potential datafile name. Given no datafile at all, means read stdin. Also  means stdin
Possible options are:
Option
 Description
 Default

l#
 number of data to use
 whole file

x#
 ignore the first # rows
 0

c#
 columns to be read
 1

m#
 minimal embedding dimensions of the vectors
 1

M#,#
 # of components, max. embedding dimension of the vectors
 1,5

d#
 delay of the vectors
 1

f#
 ratio factor
 2.0

t#
 theiler window
 0

o[#]
 output file name
 without file name: 'datafile'.fnn
(or stdin.del if stdin was read)
If no o is given stdout is used

V#
 verbosity level
0: only panic messages
1: add input/output messages
2: add information about the current state of the program
 3

h
 show these options
 none

Construction of the vectors
In case of a multivariate input the vectors are built in the following
way (n= number of components):
(x_{1}(i),...,x_{n}(i),
x_{1}(i+delay),...,x_{n}(i+delay),...,
x_{1}(i+(maxemb1)*delay),...,x_{n}(i+(maxemb1)*delay))
The minimal embedding dimension given by the m flag
just refers to the embedding of the components. That means if you
start with a three component vector and give m1
M3,3 d1 then the program starts with
(x_{1}(t),x_{2}(t),x_{3}(t))
for the first test, then it takes
(x_{1}(t),x_{2}(t),x_{3}(t),x_{1}(t+1),
x_{2}(t+1),x_{3}(t+1),)
for the next case and so forth.
Description of the Output:
output on stdout (or in the file):
first column: the dimension (counted like shown above)
second column: the fraction of false nearest neighbors
third column: the average size of the neighborhood
fourth column: the average of the squared size of the neighborhood
output on stderr:
A statistics on how many points were found up to the given
neighborhood size.
View the C source.
Table of Contents * TISEAN home