juliadynamics / statespacereconstruction.jl

State space reconstruction (SSR) for the study of dynamical system from time series.

JuliaDynamics

This repository serves the following purposes:

• Contains the source code for the JuliaDynamics website in the src and build folders.
• Hosts the website via GitHub-pages and Jekyll.
• Contains tutorials for all packages of JuliaDynamics in the tutorials folder.
• Contains video resources for all packages of JuliaDynamics in the videos folder.

---

The website was modeled after the website of QuantumOptics.jl and most code that builds the site was re-used from the repository of QuantumOptics.jl (with permission).

---

To build locally do follow the instructions from here: https://jekyllrb.com/docs/

(install Jekyll and then do bundle exec jekyll serve which serves by default to http://localhost:4000)

statespacereconstruction.jl's Issues

Move all interop with DynamicalSystems to CausalityTools

Construct trees from embeddings

Interface with NearestNeighbors.jl, so that we can construct trees directly from embeddings.

Minima and stepsizes not computed correctly

Add function to plot partitions in 3D

Given a partition of binsize(s) ϵ into integer labels, compute intervals.

Related to #7. Given a partition with binsize(s) ϵ, we assign integer labels to each bin visited by the orbit. We also need a function that does the reverse: given a set of indices and binsize(s) ϵ, compute the coordinates of the visited intervals along specified axis/axes. We can then map properties such as marginal distributions, obtained either using marginal_visitation_freq or the transfer operator estimator in PerronFrobenius.jl, onto the bins.

Simpler assignment of integer labels to bins visited by orbit

The minimum functionality needed to compute transfer entropy using traditional estimators, as in Verdes, P. F. "Assessing causality from multivariate time series." Physical Review E 72.2 (2005): 026222, is assigning integer bin labels to the elements of the partition visited by the orbit.

There should be a function that does only that and does so efficiently. Remaining functionality should be moved to relevant estimators (much of what is now done in StateSpaceReconstruction.rectangularbinning to prepare for the estimation of the transfer operator in PerronFrobenius.transferoperator should be moved to the latter.

Better triangulation machinery

New triangulation machinery

We need a more consistent way of dealing with triangulations. I propose to do this by introducing the following types.

• Simplex. Holds the vertices of the simplex. The vertices are represented as SVectors. For intersection computations, simply wrap simplexintersection and intersectingvertices from Simplices.jl. Has methods for computing:

  • Volume of the simplex.
  • Orientation of the simplex.
  • Centroid of the simplex.
  • Radius of the simplex.

• DelaunayTriangulation type. This is just a wrapper around the SVector{SVector} of simplex vertex indices. Has just one field indices.

  • Overload Base.getindex so that we have ways of accessing the indices both as a vector of vectors and as arrays. One way to go is to let d[inds] return the inds-th set of indices as a vector of vectors, and d[:, inds] return the same, but as an array of size (dim, dim + 1).

• AbstractTriangulationPartition. Subtypes of AbstractTriangulationPartition implements as a minimum two fields: data and simplexindices. We can then have concrete XxxTriangulationPartitionsubtypes that operates on different input, e.g. EmbeddingTriangulationPartition, DatasetTriangulationPartition, PointTriangulationPartition.

  • data: Holds the points from which the triangulation was computed. May be either an AbstractArray{T, 2} where T, E::T where T <: AbstractEmbedding or D::DynamicalSystemsBase.Dataset.
  • simplexindices::T where T <: AbstractTriangulation: The indices of the simplex vertices in terms of the points in data. Defaults toDelaunayTriangulation. We may open up for other ways of triangulating at a later stage, so keep this generic.
  • radii::SVector{Float64}: The radii of the simplices, in the order given by simplexindices.
  • centroids::SVector{SVector{Float64}}: The centroids of the simplices, in the order given by simplexindices.
  • orientations::SVector{Float64}: The orientations of the simplices.
  • volumes::SVector{Float64}: The volumes of the simplices.

Plotting

For plotting, we just add recipes for the different types.

We need recipes for

Simplex type

• Plotting a simplex in 2D.
• Plotting two simplices in 2D.
• Plotting more than two simplices in 2D.
• Plotting the intersection between simplices in 2D (including vertices)
• Plotting a simplex in 3D.
• Plotting two simplices in 3D.
• Plotting more than two simplices in 3D.
• Plotting the intersection between 3D simplices.

AbstractTriangulation type

These should be customiseable with options to turn off grid lines, points, etc.

• Plotting the triangulation in 2D.
• Plotting the triangulation in 3D.
• Highlighting certain simplices in the triangulation.
• Highlight intersection volumes with the triangulation.