Merge pull request #10 from JuliaDynamics/general_dataset

Dataset conversion improvement

Author: Datseris

CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.3.2
+* Orders of magnitude speed-up in conversions between `Matrix` and `Dataset`,
+  because now methods use `transpose` internally and only `reinterpret`.
+* Bugfix of `eltype` of `Reconstruction`.
+
 # v0.3.1
 * Added `jacobian` function
 * Removed `EomVector` nonsense.

src/dataset.jl

@@ -64,12 +64,15 @@ data[1] == data[1, :] # this is the first datapoint (D-dimensional)
 data[5, 3] # value of the third variable, at the 5th timepoint
 ```
 
-Use `Matrix(dataset)` to create a `Matrix`, and `Dataset(matrix)`
-to create a `Dataset` from a matrix. Notice: `Dataset(matrix)` assumes
-that each column of the matrix represents one dynamic variable. If instead each
-column of the matrix represents a datapoint, use `reinterpret(Dataset, matrix)`.
-
-If you have various timeseries vectors `x, y, z, ...` pass them like
+Use `Matrix(dataset)` or `reinterpret(Matrix, dataset) to create a `Matrix`
+from a `dataset`, the first method returning a matrix where each column is a
+a timeseries while the second returning a matrix where each column is
+a datapoint. Similarly, use
+`Dataset(matrix)` or `reinterpret(Dataset, matrix)` to create a `Dataset` from
+a `matrix` that has structure as noted by the `Matrix` methods. Notice that the 2
+matrix versions are just the transpose of each other.
+
+If you have various timeseries `Vector`s `x, y, z, ...` pass them like
 `Dataset(x, y, z, ...)`.
 
 See also [`read_dataset`](@ref), [`write_dataset`](@ref) and [`minmaxima`](@ref).
@@ -113,22 +116,20 @@ end
 
 
 # Conversions:
-@inbounds function Base.convert(::Type{Matrix}, d::AbstractDataset{D,T}) where {D, T}
-  mat = Matrix{T}(length(d), D)
-  for i in 1:length(d)
-    mat[i,:] .= d.data[i]
-  end
-  mat
+function Base.convert(::Type{Matrix}, d::AbstractDataset{D,T}) where {D, T}
+    L = length(d)
+    m = reinterpret(T, d.data, (D,L))
+    transpose(m)
+end
+
+function Base.reinterpret(::Type{M}, d::AbstractDataset{D,T}) where {M<:Matrix, D, T}
+    L = length(d)
+    reinterpret(T, d.data, (D,L))
 end
 
 function Base.convert(::Type{Dataset}, mat::AbstractMatrix)
-    D = size(mat, 2); T = eltype(mat)
-    L = size(mat, 1)
-    d = Vector{SVector{D, T}}(L)
-    for i in 1:L
-        d[i] = SVector{D, T}(view(mat, i, :))
-    end
-    return Dataset(d)
+    m = transpose(mat)
+    reinterpret(Dataset, m)
 end
 
 function Base.reinterpret(::Type{Dataset}, mat::Array{T,2}) where {T<:Real}
@@ -142,8 +143,6 @@ function Base.convert(::Type{Dataset}, y::Vector{T}) where {T}
     return Dataset(data)
 end
 
-
-
 ### Pretty printing
 function matname(d::Dataset{D, T}) where {D, T}
     N = length(d)
@@ -236,7 +235,7 @@ end
 #                                    Dataset IO                                     #
 #####################################################################################
 """
-    read_dataset(file, V::Type{Dataset{D, T}}, delim::Char = '\t'; skipstart = 0)
+    read_dataset(file, ::Type{<:Dataset}, delim::Char = '\t'; skipstart = 0)
 Read a `delim`-delimited text file directly into a dataset of dimension `D`
 with numbers of type `T`.
 

src/discrete.jl

@@ -254,7 +254,7 @@ function Base.show(io::IO, ds::DiscreteDS{N, S, F, J}) where
     {N<:ANY, S<:ANY, F<:ANY, J<:ANY}
     text = "$(dimension(ds))-dimensional discrete system"
     print(io, text*"\n",
-    " state: $(state(ds))\n", " eom: $F\n")
+    " state: $(state(ds))\n", " e.o.m.: $F\n")
 end
 
 @require Juno begin
@@ -274,7 +274,7 @@ function Base.show(io::IO, ds::BigDiscreteDS{T, F, J}) where
     {T, F<:ANY, J<:ANY}
     text = "$(dimension(ds))-dimensional Big discrete system"
     print(io, text*"\n",
-    " state: $(state(ds))\n", " eom!: $F\n")
+    " state: $(state(ds))\n", " e.o.m.: $F\n")
 end
 
 @require Juno begin
@@ -291,7 +291,7 @@ end
 ### 1-D
 function Base.show(io::IO, s::DiscreteDS1D{S, F, J}) where {S<:ANY, F<:ANY, J<:ANY}
     print(io, "1-dimensional discrete dynamical system:\n",
-    "state: $(s.state)\n", "eom: $F\n")
+    "state: $(s.state)\n", "e.o.m.: $F\n")
 end
 @require Juno begin
     function Juno.render(i::Juno.Inline, s::DiscreteDS1D{S, F, J}) where

src/reconstruction.jl

@@ -50,7 +50,6 @@ end
 Reconstruction(s::AbstractVector{T}, D, τ) where {T} =
 Reconstruction{D, T, τ}(reconstruct(s, Val{D}(), τ))
 
-@inline Base.eltype(::Reconstruction{D, T, t}) where {T,D,t} = T
 @inline delay(::Reconstruction{D, T, t}) where {T,D,t} = t
 
 function reconstruct_impl(::Type{Val{D}}) where D

test/dataset_tests.jl

@@ -19,6 +19,18 @@ using Base.Test, StaticArrays
     end
   end
 
+  @testset "Conversions" begin
+    m = Matrix(data)
+    @test Dataset(m) == data
+    @test reinterpret(Dataset, reinterpret(Matrix, data)) == data
+    @test transpose(m) == reinterpret(Matrix, data)
+
+    m = rand(1000, 4)
+    @test reinterpret(Matrix, reinterpret(Dataset, m)) == m
+    @test Dataset(m) !== Dataset(transpose(m))
+    @test Dataset(m) == reinterpret(Dataset, transpose(m))
+  end
+
   @testset "IO" begin
     @test !isfile("test.txt")
     write_dataset("test.txt", data)
@@ -32,6 +44,19 @@ using Base.Test, StaticArrays
     @test dimension(data2) == 2
 
     rm("test.txt")
+
+    write_dataset("test.txt", data, ',')
+    @test isfile("test.txt")
+
+    data3 = read_dataset("test.txt", Dataset{3, Float64}, ',')
+    @test dimension(data3) == 3
+    @test data3 == data
+
+    data2 = read_dataset("test.txt", Dataset{2, Float64})
+    @test dimension(data2) == 2
+
+    rm("test.txt")
+
     @test !isfile("test.txt") # make extra sure!
   end
 end

test/reconstruction_tests.jl

@@ -0,0 +1,18 @@
+println("\nTesting Reconstruction")
+if current_module() != DynamicalSystemsBase
+  using DynamicalSystemsBase
+end
+using Base.Test, StaticArrays
+
+@testset "Reconstruction" begin
+  ds = Systems.towel()
+  data = trajectory(ds, 10000)
+  s = data[:, 1]; N = length(s)
+  @testset "D = $(D), τ = $(τ)" for D in [2,3], τ in [2,3]
+
+    R = Reconstruction(s, D, τ)
+
+    @test R[(1+τ):end, 1] == R[1:end-τ, 2]
+    @test size(R) == (length(s) - τ*(D - 1), D)
+ end
+end