# Nonlinear Timeseries Analysis

## Broomhead-King Coordinates

`ChaosTools.broomhead_king`

— Function`broomhead_king(s::AbstractVector, d::Int) -> U, S, Vtr`

Return the Broomhead-King coordinates of a timeseries `s`

by performing `svd`

on high-dimensional embedding if `s`

with dimension `d`

with minimum delay.

**Description**

Broomhead and King coordinates is an approach proposed in ^{[Broomhead1987]} that applies the Karhunen–Loève theorem to delay coordinates embedding with smallest possible delay.

The function performs singular value decomposition on the `d`

-dimensional matrix $X$ of $s$,

\[X = \frac{1}{\sqrt{N}}\left( \begin{array}{cccc} x_1 & x_2 & \ldots & x_d \\ x_2 & x_3 & \ldots & x_{d+1}\\ \vdots & \vdots & \vdots & \vdots \\ x_{N-d+1} & x_{N-d+2} &\ldots & x_N \end{array} \right) = U\cdot S \cdot V^{tr}.\]

where $x := s - \bar{s}$. The columns of $U$ can then be used as a new coordinate system, and by considering the values of the singular values $S$ you can decide how many columns of $U$ are "important". See the documentation page for example application.

This alternative/improvement of the traditional delay coordinates can be a very powerful tool. An example where it shines is noisy data where there is the effect of superficial dimensions due to noise.

Take the following example where we produce noisy data from a system and then use Broomhead-King coordinates as an alternative to "vanilla" delay coordinates:

```
using DynamicalSystems, CairoMakie
ds = Systems.gissinger()
data = trajectory(ds, 1000.0, Δt = 0.05)
x = data[:, 1]
L = length(x)
s = x .+ 0.5rand(L) #add noise
U, S = broomhead_king(s, 40)
summary(U)
```

`"19962×40 Matrix{Float64}"`

Now let's simply compare the above result with the one you get from doing a "standard" call to `embed`

:

```
fig = Figure()
ax, = lines(fig[1,1], U[:, 1], U[:, 2])
ax.title = "Broomhead-King of s"
R = embed(s, 2, 30)
ax2, = lines(fig[1,2], columns(R)...)
ax2.title = "2D embedding of s"
fig
```

we have used the same system as in the Delay Coordinates Embedding example, and picked the optimal delay time of `τ = 30`

(for same `Δt = 0.05`

). Regardless, the vanilla delay coordinates is much worse than the Broomhead-King coordinates.

## DyCA - Dynamical Component Analysis

`ChaosTools.dyca`

— Function`dyca(data, eig_thresold) -> eigenvalues, proj_mat, projected_data`

Compute the Dynamical Component analysis (DyCA) of the given `data`

^{[Uhl2018]} used for dimensionality reduction.

Return the eigenvalues, projection matrix, and reduced-dimension data (which are just `data*proj_mat`

).

**Keyword Arguments**

- norm_eigenvectors=false : if true, normalize the eigenvectors

**Description**

Dynamical Component Analysis (DyCA) is a method to detect projection vectors to reduce the dimensionality of multi-variate, high-dimensional deterministic datasets. Unlike methods like PCA or ICA that make a stochasticity assumption, DyCA relies on a determinacy assumption on the time-series and is based on the solution of a generalized eigenvalue problem. After choosing an appropriate eigenvalue threshold and solving the eigenvalue problem, the obtained eigenvectors are used to project the high-dimensional dataset onto a lower dimension. The obtained eigenvalues measure the quality of the assumption of linear determinism for the investigated data. Furthermore, the number of the generalized eigenvalues with a value of approximately 1.0 are a measure of the number of linear equations contained in the dataset. This property is useful in detecting regions with highly deterministic parts in the time-series and also as a preprocessing step for reservoir computing of high-dimensional spatio-temporal data.

The generalised eigenvalue problem we solve is:

\[C_1 C_0^{-1} C_1^{\top} \bar{u} = \lambda C_2 \bar{u} \]

where $C_0$ is the correlation matrix of the data with itself, $C_1$ the correlation matrix of the data with its derivative, and $C_2$ the correlation matrix of the derivative of the data with itself. The eigenvectors $\bar{u}$ with eigenvalues approximately 1 and their $C_1^{-1} C_2 u$ counterpart, form the space where the data is projected onto.

## Return time statistics

`ChaosTools.mean_return_times`

— Function`mean_return_times(ds::DynamicalSystem, u₀, εs, T; kwargs...) → τ, c`

Return the mean return times `τ`

, as well as the amount of returns `c`

, for subsets of the state space of `ds`

defined by `u₀, εs`

. The `ds`

is evolved for a maximum of `T`

time. This function behaves similarly to `exit_entry_times`

and thus see that one for the meaning of `u₀`

and `εs`

.

This function supports both discrete and continuous systems, however the optimizations done in discrete systems (where all nested `ε`

-sets are checked at the same time), are not done here yet, which leads to disproportionally lower performance since each `ε`

-related set is checked individually from start.

Continuous systems allow for the following keywords:

`i=10`

How many points to interpolate the trajectory in-between steps to find candidate crossing regions.`dmin`

If the trajectory is at least`dmin`

distance away from`u0`

, the algorithm that checks for crossings of the`ε`

-set is not initiated. By default obtains the a value 4 times as large as the radius of the maximum ε-set.`diffeq`

is a`NamedTuple`

(or`Dict`

) of keyword arguments propagated into`init`

of DifferentialEquations.jl. See`trajectory`

for examples. Only valid for continuous systems.

For continuous systems `T, i, dmin`

can be vectors with same size as `εs`

, to help increase accuracy of small `ε`

.

`ChaosTools.exit_entry_times`

— Function`exit_entry_times(ds, u₀, εs, T; diffeq = NamedTuple()) → exits, entries`

Collect exit and entry times for a ball or box centered at `u₀`

with radii `εs`

(see below), in the state space of the given discrete dynamical system (function not yet available for continuous systems). Return the exit and (re-)entry return times to the set(s), where each of these is a vector containing all collected times for the respective `ε`

-radius set, for `ε ∈ εs`

.

Use `transit_return(exits, entries)`

to transform the output into transit and return times, and see also `mean_return_times`

for both continuous and discrete systems.

**Description**

Transit time statistics are important for the transport properties of dynamical systems^{[Meiss1997]} and can even be connected with the fractal dimension of chaotic sets^{[Boev2014]}.

The current algorithm collects exit and re-entry times to given sets in the state space, which are centered at `u₀`

(**algorithm always starts at u₀** and the initial state of

`ds`

is irrelevant). `εs`

is always a `Vector`

.The sets around `u₀`

are nested hyper-spheres of radius `ε ∈ εs`

, if each entry of `εs`

is a real number. The sets can also be hyper-rectangles (boxes), if each entry of `εs`

is a vector itself. Then, the `i`

-th box is defined by the space covered by `u0 .± εs[i]`

(thus the actual box size is `2εs[i]`

!).

The reason to input multiple `εs`

at once is purely for performance.

For discrete systems, exit time is recorded immediatelly after exitting of the set, and re-entry is recorded immediatelly on re-entry. This means that if an orbit needs 1 step to leave the set and then it re-enters immediatelly on the next step, the return time is 1. For continuous systems high-order interpolation is done to accurately record the time of exactly crossing the `ε`

-ball/box.

## Nearest Neighbor Prediction

Nearest neighbor timeseries prediction is a method commonly listed under nonlinear timeseries analysis. This is not part of DynamicalSystems.jl, because in JuliaDynamics we have a dedicated package for this, TimeseriesPrediction.jl.

## Timeseries Surrogates

Timeseries surrogates is a method commonly listed under nonlinear timeseries analysis. This is not part of DynamicalSystems.jl, because in JuliaDynamics we have a dedicated, small, and self-contained package for this, TimeseriesSurrogates.jl.

- Broomhead1987D. S. Broomhead, R. Jones and G. P. King, J. Phys. A
**20**, 9, pp L563 (1987) - Uhl2018B Seifert, K Korn, S Hartmann, C Uhl,
*Dynamical Component Analysis (DYCA): Dimensionality Reduction for High-Dimensional Deterministic Time-Series*, 10.1109/mlsp.2018.8517024, 2018 IEEE 28th International Workshop on Machine Learning for Signal Processing (MLSP) - Meiss1997Meiss, J. D.
*Average exit time for volume-preserving maps*, Chaos (1997)](https://doi.org/10.1063/1.166245) - Boev2014Boev, Vadivasova, & Anishchenko,
*Poincaré recurrence statistics as an indicator of chaos synchronization*, Chaos (2014)](https://doi.org/10.1063/1.4873721)