expand AbstractVectorOfArray interface

Author: ChrisRackauckas

README.md

@@ -13,7 +13,7 @@ arrays of arrays. The current functionality includes:
 #### VectorOfArray
 
 ```julia
-VectorOfArray(vec::AbstractVector)
+VectorOfArray(u::AbstractVector)
 ```
 
 A `VectorOfArray` is an array which has the underlying data structure `Vector{AbstractArray{T}}`
@@ -35,7 +35,20 @@ which act appropriate. Points to note are:
 - Iteration follows the linear index and goes over the vectors
 
 Additionally, the `vecarr_to_arr(VA::AbstractVectorOfArray)` function is provided which transforms
-the `VectorOfArray` into a matrix/tensor.
+the `VectorOfArray` into a matrix/tensor. Also, `vecarr_to_vectors(VA::AbstractVectorOfArray)`
+returns a vector of the series for each component, that is `A[i,:]` for each `i`.
+A plot recipe is provided which plots the `A[i,:]` series.
+
+#### DiffEqArray
+
+Related to the `VectorOfArray` is the `DiffEqArray`
+
+```julia
+DiffEqArray(u::AbstractVector,t::AbstractVector)
+```
+
+This is a `VectorOfArray` which stores `A.t` which matches `A.u`. This will plot
+`(A.t[i],A[i,:])`. The function `tuples(diffeq_arr)` returns tuples of `(t,u)`.
 
 #### ArrayPartition
 

REQUIRE

@@ -1,3 +1,5 @@
 julia 0.5
 Iterators
 Compat 0.17.0
+Juno
+RecipesBase 0.1.0

src/RecursiveArrayTools.jl

@@ -2,18 +2,19 @@ __precompile__()
 
 module RecursiveArrayTools
 
-  using Iterators, Compat
+  using Iterators, Compat, Juno, RecipesBase
 
   @compat abstract type AbstractVectorOfArray{T, N} <: AbstractArray{T, N} end
 
   include("utils.jl")
   include("vector_of_array.jl")
   include("array_partition.jl")
 
-  export VectorOfArray, AbstractVectorOfArray, vecarr_to_arr
+  export VectorOfArray, DiffEqArray, AbstractVectorOfArray, vecarr_to_arr,
+         vecarr_to_vectors, tuples
 
-  export recursivecopy!, vecvecapply, copyat_or_push!, vecvec_to_mat, recursive_one,
-         recursive_mean, recursive_eltype
+  export recursivecopy!, vecvecapply, copyat_or_push!, vecvec_to_mat,
+         recursive_one, recursive_mean, recursive_eltype
 
   export ArrayPartition
 

src/vector_of_array.jl

@@ -2,11 +2,21 @@
 type VectorOfArray{T, N, A} <: AbstractVectorOfArray{T, N}
   u::A # A <: AbstractVector{<: AbstractArray{T, N - 1}}
 end
+# VectorOfArray with an added series for time
+type DiffEqArray{T, N, A, B} <: AbstractVectorOfArray{T, N}
+  u::A # A <: AbstractVector{<: AbstractArray{T, N - 1}}
+  t::B
+end
 
 VectorOfArray{T, N}(vec::AbstractVector{T}, dims::NTuple{N}) = VectorOfArray{eltype(T), N, typeof(vec)}(vec)
 # Assume that the first element is representative all all other elements
 VectorOfArray(vec::AbstractVector) = VectorOfArray(vec, (size(vec[1])..., length(vec)))
 
+DiffEqArray{T, N}(vec::AbstractVector{T}, ts, dims::NTuple{N}) = DiffEqArray{eltype(T), N, typeof(vec), typeof(ts)}(vec, ts)
+# Assume that the first element is representative all all other elements
+DiffEqArray(vec::AbstractVector,ts::AbstractVector) = DiffEqArray(vec, ts, (size(vec[1])..., length(vec)))
+
+
 # Interface for the linear indexing. This is just a view of the underlying nested structure
 @inline Base.endof(VA::AbstractVectorOfArray) = endof(VA.u)
 @inline Base.length(VA::AbstractVectorOfArray) = length(VA.u)
@@ -16,6 +26,7 @@ VectorOfArray(vec::AbstractVector) = VectorOfArray(vec, (size(vec[1])..., length
 @inline Base.getindex{T, N}(VA::AbstractVectorOfArray{T, N}, I::Int) = VA.u[I]
 @inline Base.getindex{T, N}(VA::AbstractVectorOfArray{T, N}, I::Colon) = VA.u[I]
 @inline Base.getindex{T, N}(VA::AbstractVectorOfArray{T, N}, I::AbstractArray{Int}) = VA.u[I]
+@inline Base.getindex{T, N}(VA::AbstractVectorOfArray{T, N}, i::Int,::Colon) = [VA.u[j][i] for j in 1:length(VA)]
 
 # Interface for the two dimensional indexing, a more standard AbstractArray interface
 @inline Base.size(VA::AbstractVectorOfArray) = (size(VA.u[1])..., length(VA.u))
@@ -26,6 +37,7 @@ VectorOfArray(vec::AbstractVector) = VectorOfArray(vec, (size(vec[1])..., length
 Base.start{T, N}(VA::AbstractVectorOfArray{T, N}) = 1
 Base.next{T, N}(VA::AbstractVectorOfArray{T, N}, state) = (VA[state], state + 1)
 Base.done{T, N}(VA::AbstractVectorOfArray{T, N}, state) = state >= length(VA.u) + 1
+tuples(VA::DiffEqArray) = tuple.(VA.t,VA.u)
 
 # Growing the array simply adds to the container vector
 Base.copy(VA::AbstractVectorOfArray) = typeof(VA)(copy(VA.u))
@@ -41,7 +53,23 @@ end
 
 # conversion tools
 vecarr_to_arr(VA::AbstractVectorOfArray) = cat(length(size(VA)), VA.u...)
+vecarr_to_vectors(VA::AbstractVectorOfArray) = [VA[i,:] for i in eachindex(VA[1])]
 
 # make it show just like its data
 Base.show(io::IO, x::AbstractVectorOfArray) = show(io, x.u)
 Base.show(io::IO, m::MIME"text/plain", x::AbstractVectorOfArray) = show(io, m, x.u)
+
+# restore the type rendering in Juno
+Juno.@render Juno.Inline x::AbstractVectorOfArray begin
+  fields = fieldnames(typeof(x))
+  Juno.LazyTree(typeof(x), () -> [Juno.SubTree(Juno.Text("$f → "), Juno.getfield′(x, f)) for f in fields])
+end
+
+# plot recipes
+@recipe function f(VA::AbstractVectorOfArray)
+  vecarr_to_vectors(VA)
+end
+@recipe function f(VA::DiffEqArray)
+  A = vecarr_to_vectors(VA)
+  VA.t,A
+end