sssets v2 (#137)

* move to v2

* dont use `size` in docs

* all tests pass

* make changelog entry

Author: Datseris

CHANGELOG.md

@@ -1,3 +1,7 @@
+# v2.8
+
+Updated to StateSpaceSets.jl v2: the name `Dataset` no longer exists.
+
 # v2.7 - Refactoring release
 
 The package has also been updated to all new names used in DynamicalSystems.jl v3.0,

Project.toml

@@ -1,7 +1,7 @@
 name = "DelayEmbeddings"
 uuid = "5732040d-69e3-5649-938a-b6b4f237613f"
 repo = "https://github.com/JuliaDynamics/DelayEmbeddings.jl.git"
-version = "2.7.4"
+version = "2.8.0"
 
 [deps]
 Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
@@ -19,6 +19,6 @@ Distances = "0.10"
 Distributions = "0.25"
 Neighborhood = "0.2"
 Reexport = "1"
-StateSpaceSets = "1"
+StateSpaceSets = "2"
 StatsBase = "0.24, 0.32, 0.33, 0.34"
 julia = "1.5"

docs/src/separated.md

@@ -61,7 +61,7 @@ for (i, method) in enumerate(["afnn", "fnn", "f1nn", "ifnn"])
     # as well as the automated output embedding
     𝒟, τ, E = optimal_separated_de(x, method; dmax)
     lines!(ax, 1:dmax, E; label = method, marker = :circle, color = Cycled(i))
-    optimal_d = size(𝒟, 2)
+    optimal_d = dimension(𝒟)
     ## Scatter the optimal embedding dimension as a lager marker
     scatter!(ax, [optimal_d], [E[optimal_d]];
         color = Cycled(i), markersize = 30

docs/src/unified.md

@@ -145,15 +145,17 @@ Random.seed!(1234)
 d1 = randn(1000)
 d2 = rand(1000)
 Tmax = 100
-dummy_set = Dataset(d1,d2)
+dummy_set = StateSpaceSet(d1,d2)
 
 w1 = estimate_delay(d1, "mi_min")
 w2 = estimate_delay(d2, "mi_min")
 theiler = min(w1, w2)
 
-Y_d, τ_vals_d, ts_vals_d, Ls_d , ε★_d = pecuzal_embedding(dummy_set; τs = 0:Tmax , w = theiler, econ = true)
+Y_d, τ_vals_d, ts_vals_d, Ls_d , ε★_d = pecuzal_embedding(
+    dummy_set; τs = 0:Tmax , w = theiler, econ = true
+)
 
-size(Y_d)
+(length(Y_d), dimension(Y_d))
 ```
 
 So, no (proper) embedding is done.

src/DelayEmbeddings.jl

@@ -10,6 +10,14 @@ end DelayEmbeddings
 using Reexport
 @reexport using StateSpaceSets
 
+# for backwards compatibility with SSSets.jl v1
+# TODO: Cleanup: go through the instances in the codebase
+# where `oldsize` is called: replace it with `size` if the
+# input is a `Matrix`, and with `dimension` if the input is a `StateSpaceSet`.
+oldsize(s::AbstractStateSpaceSet) = (length(s), dimension(s))
+oldsize(s) = size(s)
+oldsize(s, i::Int) = oldsize(s)[i]
+
 include("embeddings/embed.jl")
 include("embeddings/genembed.jl")
 include("utils.jl")

src/separated_de/automated.jl

@@ -8,7 +8,7 @@ using the *separated* approach of first finding an optimal (and constant) delay
 time using [`estimate_delay`](@ref) with the given `dmethod`, and then an optimal
 embedding dimension, by calculating an appropriate statistic for each dimension `d ∈ 1:dmax`.
 Return the embedding `𝒟`, the optimal delay time `τ`
-(the optimal embedding dimension `d` is just `size(𝒟, 2)`) and the actual
+(the optimal embedding dimension `d` is just `dimension(𝒟)`) and the actual
 statistic `E` used to estimate optimal `d`.
 
 Notice that `E` is a function of the embedding dimension, which ranges from 1 to `dmax`.

src/unified_de/MDOP.jl

@@ -122,7 +122,7 @@ function mdop_embedding(Y::AbstractStateSpaceSet{D, T};
     τ_vals = Int64[0]
     ts_vals = Int64[]
     FNNs = Float64[]
-    βS = fill(zeros(T, length(τs), size(Y,2)), 1, max_num_of_cycles)
+    βS = fill(zeros(T, length(τs), oldsize(Y,2)), 1, max_num_of_cycles)
 
     # loop over increasing embedding dimensions until some break criterion will
     # tell the loop to stop/break
@@ -179,13 +179,13 @@ function mdop_multivariate_embedding_cycle!(
         FNNs, fnn_thres, ts_vals, NNdist_old
     )
 
-    M = size(Ys,2)
-    # in the 1st cycle we have to check all (size(Y,2)^2 combinations
+    M = oldsize(Ys,2)
+    # in the 1st cycle we have to check all (oldsize(Y,2)^2 combinations
     if counter == 1
         Y_act, NNdist_new = first_embedding_cycle_MDOP!(M, Ys, τs, w, τ_vals,
                                                 ts_vals, βS, metric, FNNs, r)
 
-    # in all other cycles we just have to check (size(Y,2)) combinations
+    # in all other cycles we just have to check (oldsize(Y,2)) combinations
     else
 
         Y_act, NNdist_new = embedding_cycle_MDOP!(Y_act, counter, NNdist_old, M, Ys, τs, w,
@@ -281,7 +281,7 @@ corresponding to that maximum of maxima. In this first embedding cycle it also
 returns the time series number, which act as Y_act.
 """
 function choose_optimal_tau1(βs::Array{T, 2}, M::Int) where {T}
-    NN = size(βs,2)
+    NN = oldsize(βs,2)
     maxis = zeros(T, NN)
     max_idx = zeros(Int, NN)
     for i = 1:NN
@@ -303,7 +303,7 @@ maxima. It returns the index of this maximum as well as the time series number
 corresponding to that maximum of maxima.
 """
 function choose_optimal_tau2(βs::Array{T, 2}) where {T}
-    NN = size(βs,2)
+    NN = oldsize(βs,2)
     maxis = zeros(T, NN)
     max_idx = zeros(Int, NN)
     for i = 1:NN
@@ -413,7 +413,7 @@ considered in the computation of `L` (see [`uzal_cost`](@ref)). When this
 statistic reaches its global minimum the maximum delay value `τ_max` gets
 returned. When `s` is a multivariate `StateSpaceSet`, `τ_max` will becomputed for all
 timeseries of that StateSpaceSet and the maximum value will be returned. The returned
-`L`-statistic has size `(length(tw), size(s,2))`.
+`L`-statistic has size `(length(tw), oldsize(s,2))`.
 
 [^Nichkawde2013]: Nichkawde, Chetan (2013). [Optimal state-space reconstruction using derivatives on projected manifold. Physical Review E 87, 022905](https://doi.org/10.1103/PhysRevE.87.022905).
 [^Uzal2011]: Uzal, L. C., Grinblat, G. L., Verdes, P. F. (2011). [Optimal reconstruction of dynamical systems: A noise amplification approach. Physical Review E 84, 016223](https://doi.org/10.1103/PhysRevE.84.016223).

src/unified_de/garcia_almeida.jl

@@ -131,7 +131,7 @@ function garcia_almeida_embedding(Y::AbstractStateSpaceSet{D, F}; τs = 0:50 , w
     τ_vals = Int64[0]
     ts_vals = Int64[1]
     FNNs = Float64[]
-    NS = fill(zeros(F, length(τs), size(Y,2)), 1, max_num_of_cycles)
+    NS = fill(zeros(F, length(τs), oldsize(Y,2)), 1, max_num_of_cycles)
 
     # loop over increasing embedding dimensions until some break criterion will
     # tell the loop to stop/break
@@ -282,14 +282,14 @@ function garcia_multivariate_embedding_cycle!(
     FNNs, fnn_thres, ts_vals, NNdist_old
     )
 
-    M = size(Ys,2)
-    # in the 1st cycle we have to check all (size(Y,2)^2 combinations
+    M = oldsize(Ys,2)
+    # in the 1st cycle we have to check all (oldsize(Y,2)^2 combinations
     if counter == 1
         Y_act, NNdist_new = first_embedding_cycle!(M, Ys, τs, r1, r2, T, w,
                                                 metric, τ_vals, ts_vals,
                                                 NS, FNNs)
 
-    # in all other cycles we just have to check (size(Y,2)) combinations
+    # in all other cycles we just have to check (oldsize(Y,2)) combinations
     else
         Y_act, NNdist_new = embedding_cycle!(Y_act, M, counter, Ys, τs, r1, r2, T, w,
                                             metric, NNdist_old, τ_vals, ts_vals,
@@ -386,7 +386,7 @@ time series number corresponding to that 1st minimum of all 1st minima. In this
 first embedding cycle it also returns the time series number, which act as Y_act.
 """
 function choose_optimal_tau1_garcia(Ns::Array{T, 2}, M::Int) where {T}
-    NN = size(Ns,2)
+    NN = oldsize(Ns,2)
     min_idx = zeros(Int, NN)
     for i = 1:NN
         # determine optimal tau value and minimum vals from all N-statistic's
@@ -408,7 +408,7 @@ of the N-statistics. It returns the index of this 1st minimum as well as the
 time series number corresponding to that 1st minimum of the 1st minima.
 """
 function choose_optimal_tau2_garcia(Ns::Array{T, 2}) where {T}
-    NN = size(Ns,2)
+    NN = oldsize(Ns,2)
     min_idx = zeros(Int, NN)
     for i = 1:NN
         # determine optimal tau value and minimum vals from all N-statistic's

src/unified_de/pecora.jl

@@ -252,11 +252,11 @@ function pecora(
     return all_ε★, all_Γ
 end
 
-maxdimspan(s) = 1:size(s)[2]
-maxdimspan(s::AbstractVector) = 1
+maxdimspan(s) = 1:oldsize(s)[2]
+maxdimspan(s::AbstractVector{<:Real}) = 1
 
 function continuity_per_timeseries(x::AbstractVector, ns, allNNidxs, delays, K, α, p)
-    avrg_ε★ = zeros(size(delays))
+    avrg_ε★ = zeros(oldsize(delays))
     Ks = [k for k in 8:K]
     δ_to_ε_amount = get_binomial_table(p, α; trial_range = length(Ks))
     for (ι, τ) in enumerate(delays) # Loop over the different delays
@@ -293,7 +293,7 @@ end
 # Undersampling statistic code
 ##########################################################################################
 function undersampling_per_timeseries(x, vspace, ns, uidxs, udist, JS, delays, ρs)
-    avrg_Γ = zeros(size(delays))
+    avrg_Γ = zeros(oldsize(delays))
     for (ι, τ) in enumerate(delays) # loop over delay times
         println("τ = $τ")
         c = 0

src/unified_de/pecuzal.jl

@@ -161,7 +161,7 @@ function pecuzal_embedding(Y::StateSpaceSet{D, T}; τs = 0:50 , w::Int = 1,
     τ_vals = Int64[0]
     ts_vals = Int64[]
     Ls = Float64[]
-    ε★s = fill(zeros(T, length(τs), size(Y,2)), 1, max_cycles)
+    ε★s = fill(zeros(T, length(τs), oldsize(Y,2)), 1, max_cycles)
 
     # loop over increasing embedding dimensions until some break criterion will
     # tell the loop to stop/break
@@ -223,13 +223,13 @@ function pecuzal_multivariate_embedding_cycle!(Y_act, flag::Bool,
         samplesize::Real, K::Int, α::Real, p::Real, KNN::Int, econ::Bool
     )
 
-    M = size(Ys,2)
-    # in the 1st cycle we have to check all (size(Y,2)^2 combinations and pick
+    M = oldsize(Ys,2)
+    # in the 1st cycle we have to check all (oldsize(Y,2)^2 combinations and pick
     # the tau according to maximum L-statistic decrease)
     if counter == 1
         Y_act = first_embedding_cycle_pecuzal!(Ys, M, τs, w, samplesize, K,
                                 metric, α, p, KNN, τ_vals, ts_vals, Ls, ε★s, econ)
-    # in all other cycles we just have to check (size(Y,2)) combinations and pick
+    # in all other cycles we just have to check (oldsize(Y,2)) combinations and pick
     # the tau according to maximum L-statistic decrease
     else
         Y_act = embedding_cycle_pecuzal!(Y_act, Ys, counter, M, τs, w, samplesize,
@@ -257,6 +257,7 @@ function first_embedding_cycle_pecuzal!(Ys::StateSpaceSet{D, T}, M::Int, τs, w:
         ε★[:,1+(M*(ts-1)):M*ts], _ = pecora(Ys, (0,), (ts,); delays = τs,
                     w = w, samplesize = samplesize, K = K, metric = metric,
                     α = α, p = p, undersampling = false)
+
         L_min[ts], L_min_idx[ts], idx[ts]  = choose_right_embedding_params(
                                         ε★[:,1+(M*(ts-1)):M*ts], Ys[:,ts],
                                         Ys, τs, KNN, w, samplesize,
@@ -308,9 +309,9 @@ function choose_right_embedding_params!(ε★::AbstractMatrix, Y_act,
             Ls::Vector{T}, ε★s::AbstractMatrix, counter::Int, τs, KNN::Int,
             w::Int, samplesize::Real, metric, econ::Bool) where {D, T}
 
-    L_min_ = zeros(size(Ys,2))
-    τ_idx = zeros(Int,size(Ys,2))
-    for ts = 1:size(Ys,2)
+    L_min_ = zeros(oldsize(Ys,2))
+    τ_idx = zeros(Int,oldsize(Ys,2))
+    for ts = 1:oldsize(Ys,2)
         # zero-padding of ⟨ε★⟩ in order to also cover τ=0 (important for the multivariate case)
         # get the L-statistic for each peak in ⟨ε★⟩ and take the one according to L_min
         L_trials_, max_idx_ = local_L_statistics(vec([0; ε★[:,ts]]), Y_act, Ys[:,ts],
@@ -336,9 +337,9 @@ the chosen peak `τ_idx` and the number of the chosen time series to start with
 function choose_right_embedding_params(ε★::AbstractMatrix, Y_act,
             Ys::StateSpaceSet{D, T}, τs, KNN::Int, w::Int, samplesize::Real, metric,
             econ::Bool) where {D, T}
-    L_min_ = zeros(size(Ys,2))
-    τ_idx = zeros(Int,size(Ys,2))
-    for ts = 1:size(Ys,2)
+    L_min_ = zeros(oldsize(Ys,2))
+    τ_idx = zeros(Int,oldsize(Ys,2))
+    for ts = 1:oldsize(Ys,2)
         # zero-padding of ⟨ε★⟩ in order to also cover τ=0 (important for the multivariate case)
         # get the L-statistic for each peak in ⟨ε★⟩ and take the one according to L_min
         L_trials_, max_idx_ = local_L_statistics(vec([0; ε★[:,ts]]), StateSpaceSet(Y_act), Ys[:,ts],
@@ -585,7 +586,7 @@ function comp_Ek2!(ϵ_ball::Array{P, 2}, u_k::Vector{P}, Y::StateSpaceSet{D, P},
     end
 
     # compute center of mass
-    @inbounds for i in 1:size(Y)[2]; u_k[i] = sum(view(ϵ_ball, :, i))/(K+1); end # Eq. 14
+    @inbounds for i in 1:oldsize(Y)[2]; u_k[i] = sum(view(ϵ_ball, :, i))/(K+1); end # Eq. 14
 
     E²_sum = 0
     @inbounds for j = 1:K+1