# Contents

When you do `using DynamicalSystems`

in your Julia session, the module re-exports and brings into scope all submodules (Julia packages) that compose **DynamicalSystems.jl**. These are listed in this page. Of course, you could be using these packages directly instead of adding `DynamicalSystems`

. However, doing `using DynamicalSystems`

provides the environment all these packages were designed to work together in, and so we recommend to simply install `DynamicalSystems`

and use that.

## Exported submodules

The submodules that compose **DynamicalSystems.jl** are the following packages, which are re-exported by `DynamicalSystems`

:

**Core**

**For observed/measured data**

**For dynamical system instances**

At the very end of this page, a full list of exported names is presented.

## Core

`StateSpaceSets.StateSpaceSets`

— Module**StateSpaceSets.jl**

A Julia package that provides functionality for state space sets. These are ordered collections of points of fixed length (called dimension). It is used by many other packages in the JuliaDynamics organization. The main export of `StateSpaceSets`

is the concrete type `StateSpaceSet`

. The package also provides functionality for distances, neighbor searches, sampling, and normalization.

To install it you may run `import Pkg; Pkg.add("StateSpaceSets")`

, however, there is no real reason to install this package directly as it is re-exported by all downstream packages that use it.

`DynamicalSystemsBase.DynamicalSystemsBase`

— Module**DynamicalSystemsBase.jl**

A Julia package that defines the `DynamicalSystem`

interface and many concrete implementations used in the DynamicalSystems.jl ecosystem.

To install it, run `import Pkg; Pkg.add("DynamicalSystemsBase")`

. Typically, you do not want to use `DynamicalSystemsBase`

directly, as downstream analysis packages re-export it.

All further information is provided in the documentation, which you can either find online or build locally by running the `docs/make.jl`

file.

## For observed/measured data

`ComplexityMeasures.ComplexityMeasures`

— Module**ComplexityMeasures.jl**

ComplexityMeasures.jl is a Julia-based software for calculating 1000s of various kinds of probabilities, entropies, and other so-called *complexity measures* from a single-variable input datasets. For relational measures across many input datasets see its extension CausalityTools.jl. If you are a user of other programming languages (Python, R, MATLAB, ...), you can still use ComplexityMeasures.jl due to Julia's interoperability. For example, for Python use `juliacall`

.

A careful comparison with alternative widely used software shows that ComplexityMeasures.jl outclasses the alternatives in several objective aspects of comparison, such as computational performance, overall amount of measures, reliability, and extendability. See the associated publication for more details.

The key features that it provides can be summarized as:

- A rigorous framework for extracting probabilities from data, based on the mathematical formulation of probability spaces.
- Several (12+) outcome spaces, i.e., ways to discretize data into probabilities.
- Several estimators for estimating probabilities given an outcome space, which correct theoretically known estimation biases.
- Several definitions of information measures, such as various flavours of entropies (Shannon, Tsallis, Curado...), extropies, and other complexity measures, that are used in the context of nonlinear dynamics, nonlinear timeseries analysis, and complex systems.
- Several discrete and continuous (differential) estimators for entropies, which correct theoretically known estimation biases.
- An extendable interface and well thought out API accompanied by dedicated developer documentation. This makes it trivial to define new outcome spaces, or new estimators for probabilities, information measures, or complexity measures and integrate them with everything else in the software without boilerplate code.

ComplexityMeasures.jl can be used as a standalone package, or as part of other projects in the JuliaDynamics organization, such as DynamicalSystems.jl or CausalityTools.jl.

To install it, run `import Pkg; Pkg.add("ComplexityMeasures")`

.

All further information is provided in the documentation, which you can either find online or build locally by running the `docs/make.jl`

file.

*Previously, this package was called Entropies.jl.*

`RecurrenceAnalysis.RecurrenceAnalysis`

— Module**RecurrenceAnalysis.jl**

A Julia package that offers tools for computing Recurrence Plots and exploring them within the framework of Recurrence Quantification Analysis and Recurrence Network Analysis. It can be used as a standalone package, or as part of DynamicalSystems.jl.

To install it, run `import Pkg; Pkg.add("RecurrenceAnalysis")`

.

All further information is provided in the documentation, which you can either find online or build locally by running the `docs/make.jl`

file.

`DelayEmbeddings.DelayEmbeddings`

— Module**DelayEmbeddings.jl**

A Julia package that provides a generic interface for performing delay coordinate embeddings, as well as cutting edge algorithms for creating optimal embeddings given some data. It can be used as a standalone package, or as part of DynamicalSystems.jl.

To install it, run `import Pkg; Pkg.add("DelayEmbeddings")`

.

`docs/make.jl`

file.

`FractalDimensions.FractalDimensions`

— Module**FractalDimensions.jl**

A Julia package that estimates various definitions of fractal dimension from data. It can be used as a standalone package, or as part of DynamicalSystems.jl.

To install it, run `import Pkg; Pkg.add("FractalDimensions")`

.

`docs/make.jl`

file.

*Previously, this package was part of ChaosTools.jl.*

**Publication**

FractalDimensions.jl is used in a review article comparing various estimators for fractal dimensions. The paper is likely a relevant read if you are interested in the package. And if you use the package, please cite the paper.

```
@article{FractalDimensions.jl,
doi = {10.1063/5.0160394},
url = {https://doi.org/10.1063/5.0160394},
year = {2023},
month = oct,
publisher = {{AIP} Publishing},
volume = {33},
number = {10},
author = {George Datseris and Inga Kottlarz and Anton P. Braun and Ulrich Parlitz},
title = {Estimating fractal dimensions: A comparative review and open source implementations},
journal = {Chaos: An Interdisciplinary Journal of Nonlinear Science}
}
```

`TimeseriesSurrogates.TimeseriesSurrogates`

— Module**TimeseriesSurrogates.jl**

A Julia package for generating timeseries surrogates. TimeseriesSurrogates.jl is the fastest and most featureful open source code for generating timeseries surrogates. It can be used as a standalone package, or as part of other projects in JuliaDynamics such as DynamicalSystems.jl or CausalityTools.jl.

To install it, run `import Pkg; Pkg.add("TimeseriesSurrogates")`

.

`docs/make.jl`

file.

**Citing**

Please use the following BiBTeX entry, or DOI, to cite TimeseriesSurrogates.jl:

DOI: https://doi.org/10.21105/joss.04414

BiBTeX:

```
@article{TimeseriesSurrogates.jl,
doi = {10.21105/joss.04414},
url = {https://doi.org/10.21105/joss.04414},
year = {2022},
publisher = {The Open Journal},
volume = {7},
number = {77},
pages = {4414},
author = {Kristian Agasøster Haaga and George Datseris},
title = {TimeseriesSurrogates.jl: a Julia package for generating surrogate data},
journal = {Journal of Open Source Software}
}
```

## For dynamical system instances

`PredefinedDynamicalSystems.PredefinedDynamicalSystems`

— Module**PredefinedDynamicalSystems.jl**

Module which contains pre-defined dynamical systems that can be used by the DynamicalSystems.jl library. To install it, run `import Pkg; Pkg.add("PredefinedDynamicalSystems")`

.

Predefined systems exist as functions that return a `DynamicalSystem`

instance. They are accessed like:

`ds = PredefinedDynamicalSystems.lorenz(u0; ρ = 32.0)`

The alias `Systems`

is also exported as a deprecation.

**This module is provided purely as a convenience. It does not have any actual tests, and it is not guaranteed to be stable in future versions. It is not recommended to use this module for anything else besides on-the-spot demonstrative examples.**

For some systems, a Jacobian function is also defined. The naming convention for the Jacobian function is `\$(name)_jacob`

. So, for the above example we have `J = Systems.lorenz_jacob`

.

All available systems are provided in the documentation, which you can either find online or build locally by running the `docs/make.jl`

file.

`ChaosTools.ChaosTools`

— Module**ChaosTools.jl**

A Julia module that offers various tools for analysing nonlinear dynamics and chaotic behaviour. It can be used as a standalone package, or as part of DynamicalSystems.jl.

To install it, run `import Pkg; Pkg.add("ChaosTools")`

.

`docs/make.jl`

file.

*ChaosTools.jl is the jack-of-all-trades package of the DynamicalSystems.jl library: methods that are not extensive enough to be a standalone package are added here. You should see the full DynamicalSystems.jl library for other packages that may contain functionality you are looking for but did not find in ChaosTools.jl.*

`Attractors.Attractors`

— Module**Attractors.jl**

Attractors.jl is a Julia package for

- Finding all attractors, and all types of attractors, of arbitrary dynamical systems. An extendable interface allows for new algorithms for finding attractors.
- Finding their basins of attraction or the state space fractions of the basins. This includes finding exit basins (divergence to infinity).
- Analyzing nonlocal stability of attractors (also called global stability or resilience).
- Performing
**global continuation**of attractors and their basins (or other measures of stability), over a parameter range. Global continuation is a new, cutting-edge type of continuation that offers several advantages over traditional local continuation (AUTO, MatCont, BifurcationKit.jl, etc.), see the comparison in our docs. - Finding the basin boundaries and edges states and analyzing their fractal properties.
- Tipping points related functionality for systems with known dynamic rule.
- And more!

It can be used as a standalone package, or as part of DynamicalSystems.jl.

To install it, run `import Pkg; Pkg.add("Attractors")`

.

`docs/make.jl`

file.

*Previously, Attractors.jl was part of ChaosTools.jl*

## All exported names

This section lists all exported names of the **DynamicalSystems.jl** library. We do not list their documentation in any way here. This list is only meant as a quantitative listing of features, as well as perhaps helping searching via the search bar. To actually learn how to use all these exported names you need to use above-linked documentation of the respective submodules!

The total exported names are:

```
using DynamicalSystems
all_exported_names = names(DynamicalSystems)
length(all_exported_names)
```

`503`

And they are:

```
using DisplayAs
DisplayAs.unlimited(all_exported_names)
```

```
503-element Array{Symbol, 1}:
:..
Symbol("@windowed")
:AAFT
:AR1
:AbstractBinning
:AbstractEmbedding
:AbstractRecurrenceType
:AbstractStateSpaceSet
:AddConstant
:AlizadehArghami
:AllSlopesDistribution
:AmplitudeAwareOrdinalPatterns
:ApproximateEntropy
:ArbitrarySteppable
:AttractorMapper
:AttractorSeedContinueMatch
:Attractors
:AttractorsBasinsContinuation
:AttractorsViaFeaturizing
:AttractorsViaProximity
:AttractorsViaRecurrences
:AutoRegressive
:BayesianRegularization
:BlockMaxima
:BlockShuffle
:BruteForce
:BubbleEntropy
:BubbleSortSwaps
:BubbleSortSwapsEncoding
:Centroid
:ChaoShen
:ChaosTools
:Chebyshev
:CircShift
:Cityblock
:ClusteringConfig
:CombinationEncoding
:ComplexityEstimator
:ComplexityMeasure
:ComplexityMeasures
:CompositeDownsampling
:ContinuousDynamicalSystem
:ContinuousTimeDynamicalSystem
:CoreDynamicalSystem
:Correa
:CosineSimilarityBinning
:CountOccurrences
:Counts
:CoupledODEs
:CoupledSDEs
:CramerVonMises
:CrossRecurrenceMatrix
:CrossingAccurateInterpolation
:CrossingLinearIntersection
:Curado
:CycleShuffle
:DelayEmbedding
:DelayEmbeddings
:DeterministicIteratedMap
:DifferentialEntropyEstimator
:DifferentialInfoEstimator
:DiscreteDynamicalSystem
:DiscreteEntropyEstimator
:DiscreteInfoEstimator
:DiscreteTimeDynamicalSystem
:Dispersion
:Diversity
:DynamicalSystem
:DynamicalSystems
:DynamicalSystemsBase
:Ebrahimi
:EdgeTrackingResults
:ElectronicEntropy
:Encoding
:EntropyDefinition
:Euclidean
:Exceedances
:FAN
:FT
:FeaturizeGroupAcrossParameter
:FirstElement
:FixedRectangularBinning
:FluctuationComplexity
:FractalDimensions
:Gao
:GaussianCDFEncoding
:GeneralizedEmbedding
:GeneralizedSchuermann
:GlobalContinuationAlgorithm
:GlobalRecurrenceRate
:Goria
:GroupAcrossParameter
:GroupAcrossParameterContinuation
:GroupViaClustering
:GroupViaHistogram
:GroupViaNearestFeature
:GroupViaPairwiseComparison
:GroupingConfig
:HRectangle
:HSphere
:HSphereSurface
:Hausdorff
:HorvitzThompson
:IAAFT
:IDMatcher
:Identification
:InformationMeasure
:InformationMeasureEstimator
:IntervalBox
:InvariantMeasure
:IrregularLombScargle
:Jackknife
:JointRecurrenceMatrix
:KDTree
:Kaniadakis
:KozachenkoLeonenko
:Kraskov
:LargestLinearRegion
:LempelZiv76
:LeonenkoProzantoSavani
:LinearRegression
:LocalRecurrenceRate
:Lord
:MFSBlackBoxOptim
:MFSBruteForce
:MLEntropy
:MVector
:MatchByBasinEnclosure
:MatchByBasinOverlap
:MatchBySSSetDistance
:MillerMadow
:MissingDispersionPatterns
:MultiScaleAlgorithm
:NLNS
:NSAR2
:NaiveKernel
:NeighborNumber
:OrdinalPatternEncoding
:OrdinalPatterns
:Outcome
:OutcomeSpace
:PairDistanceEncoding
:ParallelDynamicalSystem
:PartialRandomization
:PartialRandomizationAAFT
:PlaneCrossing
:PlugIn
:PoincareMap
:PowerSpectrum
:PredefinedDynamicalSystems
:Probabilities
:ProbabilitiesEstimator
:ProjectedDynamicalSystem
:PseudoPeriodic
:PseudoPeriodicTwin
:RAFM
:RandomCascade
:RandomFourier
:RandomShuffle
:RectangularBinEncoding
:RectangularBinning
:RecurrenceAnalysis
:RecurrenceMatrix
:RecurrenceThreshold
:RecurrenceThresholdScaled
:RecurrencesFindAndMatch
:RecurrencesSeededContinuation
:RegularDownsampling
:RelativeAmount
:RelativeFirstDifferenceEncoding
:RelativeMeanEncoding
:RelativePartialRandomization
:RelativePartialRandomizationAAFT
:Renyi
:RenyiExtropy
:ReverseDispersion
:SMatrix
:SNLST
:SVector
:SampleEntropy
:Schuermann
:SequentialPairDistances
:Shannon
:ShannonExtropy
:Shrinkage
:ShuffleDimensions
:SpatialBubbleSortSwaps
:SpatialDispersion
:SpatialOrdinalPatterns
:SpectralPartialRandomization
:SpectralPartialRandomizationAAFT
:StateSpaceSet
:StateSpaceSets
:StatisticalComplexity
:StretchedExponential
:StrictlyMinimumDistance
:StroboscopicMap
:SubdivisionBasedGrid
:Surrogate
:SurrogateTest
:SymbolicAmplitudeAwarePermutation
:SymbolicPermutation
:SymbolicWeightedPermutation
:Systems
:TAAFT
:TFTD
:TFTDAAFT
:TFTDIAAFT
:TFTDRandomFourier
:TFTS
:TangentDynamicalSystem
:TimeScaleMODWT
:TimeseriesSurrogates
:TransferOperator
:Tsallis
:TsallisExtropy
:UniqueElements
:UniqueElementsEncoding
:ValueBinning
:ValueHistogram
:Vasicek
:VisitationFrequency
:WLS
:WaveletOverlap
:WeightedOrdinalPatterns
:WithinRange
:Zhu
:ZhuSingh
:aggregate_attractor_fractions
:allcounts
:allcounts_and_outcomes
:allprobabilities
:allprobabilities_and_outcomes
:animate_attractors_continuation
:autocor
:automatic_Δt_basins
:basin_entropy
:basins_fractal_dimension
:basins_fractal_test
:basins_fractions
:basins_of_attraction
:beta_statistic
:bisect_to_edge
:boxassisted_correlation_dim
:boxed_correlationsum
:broomhead_king
:codify
:colored_noise
:columns
:complexity
:complexity_normalized
:continuation
:convergence_and_basins_fractions
:convergence_and_basins_of_attraction
:convergence_time
:convert_logunit
:coordinates
:cor
:correlationsum
:counts
:counts_and_outcomes
:cov
:current_crossing_time
:current_deviations
:current_parameter
:current_parameters
:current_state
:current_states
:current_time
:davidchacklai
:decode
:delay_afnn
:delay_f1nn
:delay_fnn
:delay_ifnn
:determinism
:dimension
:distancematrix
:divergence
:dl_average
:dl_entropy
:dl_max
:downsample
:dyca
:dynamic_rule
:edgetracking
:embed
:encode
:entropy
:entropy_approx
:entropy_complexity
:entropy_complexity_curves
:entropy_dispersion
:entropy_distribution
:entropy_maximum
:entropy_normalized
:entropy_permutation
:entropy_sample
:entropy_wavelet
:estimate_boxsizes
:estimate_delay
:estimate_gev_parameters
:estimate_gev_scale
:estimate_gpd_parameters
:estimate_period
:estimate_r0_buenoorovio
:estimate_r0_theiler
:excitability_threshold
:exit_entry_times
:expansionentropy
:exponential_decay_fit
:extract_attractors
:extract_features
:extremal_index_sueveges
:extremevaltheory_dim
:extremevaltheory_dims
:extremevaltheory_dims_persistences
:extremevaltheory_gpdfit_pvalues
:extremevaltheory_local_dim_persistence
:fill_surrogate_test!
:findlocalextrema
:findlocalminima
:first_return_times
:fixedmass_correlation_dim
:fixedmass_correlationsum
:fixedpoints
:gali
:garcia_almeida_embedding
:genembed
:genentropy
:generalized_dim
:get_deviations
:get_state
:global_continuation
:grassberger_proccacia_dim
:grayscale
:group_features
:haussdorff_distance
:heatmap_basins_attractors
:heatmap_basins_attractors!
:higuchi_dim
:information
:information_maximum
:information_normalized
:initial_parameters
:initial_state
:initial_states
:initial_time
:integrator
:interactive_cobweb
:interactive_orbitdiagram
:interactive_poincaresos
:interactive_poincaresos_scan
:interactive_trajectory
:interactive_trajectory_timeseries
:interval
:invariantmeasure
:is_counting_based
:isdeterministic
:isdiscretetime
:isinplace
:jacobian
:kaplanyorke_dim
:lambdamatrix
:lambdaperms
:laminarity
:linear_region
:linear_regions
:linreg
:local_growth_rates
:lyapunov
:lyapunov_from_data
:lyapunovspectrum
:match_attractor_ids!
:match_basins_ids!
:match_continuation!
:match_sequentially!
:match_statespacesets!
:matching_map
:matching_map!
:maxima
:mdop_embedding
:mdop_maximum_delay
:mean_and_cov
:mean_return_times
:meanrecurrencetime
:minima
:minimal_fatal_shock
:minimum_pairwise_distance
:minmaxima
:missing_outcomes
:missing_probabilities
:molteno_boxing
:molteno_dim
:multiscale
:multiscale_normalized
:n_statistic
:next_free_id
:nmprt
:noiseradius
:observe_state
:optimal_separated_de
:optimal_traditional_de
:orbitdiagram
:orthonormal
:outcome_space
:outcomes
:parallel_integrator
:parameter_name
:pecora
:pecuzal_embedding
:periodicorbits
:permentropy
:plot_attractors
:plot_attractors!
:plot_attractors_curves
:plot_attractors_curves!
:plot_basins_attractors_curves
:plot_basins_attractors_curves!
:plot_basins_curves
:plot_basins_curves!
:plot_continuation_curves
:plot_continuation_curves!
:poincaremap
:poincaresos
:pointwise_correlationsums
:pointwise_dimensions
:predictability
:prismdim_theiler
:probabilities
:probabilities!
:probabilities_and_outcomes
:produce_orbitdiagram
:projected_integrator
:pvalue
:random_cycles
:randomwalk
:reconstruct
:recurrence_threshold
:recurrenceplot
:recurrencerate
:recurrencestructures
:recursivecopy
:referrenced_sciml_model
:reinit!
:rematch!
:replacement_map
:reset_mapper!
:rna
:rqa
:rt_average
:rt_entropy
:rt_max
:scaleod
:selfmutualinfo
:set_deviations!
:set_distance
:set_parameter!
:set_parameters!
:set_period!
:set_state!
:setsofsets_distances
:shaded_basins_heatmap
:shaded_basins_heatmap!
:skeletonize
:slopefit
:sorteddistances
:standardize
:state_name
:statespace_sampler
:step!
:stochastic_indicator
:subdivision_based_grid
:successful_step
:surrogate
:surrogenerator
:surroplot
:surroplot!
:swap_dict_keys!
:takens_best_estimate_dim
:tangent_integrator
:test_wada_merge
:testchaos01
:textrecurrenceplot
:tipping_probabilities
:total_outcomes
:trajectory
:transfermatrix
:transit_return_times
:transitivity
:trappingtime
:trend
:uncertainty_exponent
:unique_keys
:uzal_cost
:uzal_cost_local
:vl_average
:vl_entropy
:vl_max
:windowed
:yin
:×
:τrange
```