Rearrange code and fix couple of bugs

Author: sharanry

src/vector_of_array.jl

@@ -12,6 +12,21 @@ mutable struct DiffEqArray{T, N, A, B, C, D, E, F} <: AbstractDiffEqArray{T, N,
   p::F
 end
 
+Base.@pure __parameterless_type(T) = Base.typename(T).wrapper
+parameterless_type(x) = parameterless_type(typeof(x))
+parameterless_type(x::Type) = __parameterless_type(x)
+
+### Abstract Interface
+struct AllObserved
+end
+issymbollike(x) = x isa Symbol ||
+                  x isa AllObserved ||
+                  Symbol(parameterless_type(typeof(x))) == :Operation ||
+                  Symbol(parameterless_type(typeof(x))) == :Variable ||
+                  Symbol(parameterless_type(typeof(x))) == :Sym ||
+                  Symbol(parameterless_type(typeof(x))) == :Num ||
+                  Symbol(parameterless_type(typeof(x))) == :Term
+
 Base.Array(VA::AbstractVectorOfArray{T,N,A}) where {T,N,A <: AbstractVector{<:AbstractVector}} = reduce(hcat,VA.u)
 Base.Array(VA::AbstractVectorOfArray{T,N,A}) where {T,N,A <: AbstractVector{<:Number}} = VA.u
 function Base.Array(VA::AbstractVectorOfArray)
@@ -43,22 +58,6 @@ Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, I::Int)
 Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, I::Colon) where {T, N} = VA.u[I]
 Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, I::AbstractArray{Int}) where {T, N} = VectorOfArray(VA.u[I])
 Base.@propagate_inbounds Base.getindex(VA::AbstractDiffEqArray{T, N}, I::AbstractArray{Int}) where {T, N} = DiffEqArray(VA.u[I],VA.t[I])
-# 
-Base.@pure __parameterless_type(T) = Base.typename(T).wrapper
-parameterless_type(x) = parameterless_type(typeof(x))
-parameterless_type(x::Type) = __parameterless_type(x)
-
-### Abstract Interface
-struct AllObserved
-end
-issymbollike(x) = x isa Symbol ||
-                  x isa AllObserved ||
-                  Symbol(parameterless_type(typeof(x))) == :Operation ||
-                  Symbol(parameterless_type(typeof(x))) == :Variable ||
-                  Symbol(parameterless_type(typeof(x))) == :Sym ||
-                  Symbol(parameterless_type(typeof(x))) == :Num ||
-                  Symbol(parameterless_type(typeof(x))) == :Term
-
 Base.@propagate_inbounds function Base.getindex(A::AbstractDiffEqArray{T, N},sym) where {T, N}
   if issymbollike(sym)
     i = findfirst(isequal(Symbol(sym)),A.syms)
@@ -74,7 +73,7 @@ Base.@propagate_inbounds function Base.getindex(A::AbstractDiffEqArray{T, N},sym
       observed(A,sym,:)
     end
   else
-    A[i,:]
+    Base.getindex.(A.u, i)
   end
 end
 Base.@propagate_inbounds function Base.getindex(A::AbstractDiffEqArray{T, N},sym,args...) where {T, N}
@@ -92,23 +91,21 @@ Base.@propagate_inbounds function Base.getindex(A::AbstractDiffEqArray{T, N},sym
       observed(A,sym,args...)
     end
   else
-    A[i,args...]
+    Base.getindex.(A.u, args...)
   end
 end
-Base.@propagate_inbounds Base.getindex(A::AbstractDiffEqArray{T, N} where {T, N}, i::Int64, ::Colon) = Base.getindex.(A.u, i)
-
+Base.@propagate_inbounds Base.getindex(A::AbstractDiffEqArray{T, N}, I::Int...) where {T, N} = A.u[I[end]][Base.front(I)...]
+Base.@propagate_inbounds Base.getindex(A::AbstractDiffEqArray{T, N}, i::Int) where {T, N} = A.u[i]
 function observed(A::AbstractDiffEqArray{T, N},sym,i::Int) where {T, N}
     A.observed(sym,A.u[i],A.p,A.t[i])
 end
-
 function observed(A::AbstractDiffEqArray{T, N},sym,i::AbstractArray{Int}) where {T, N}
     A.observed.((sym,),A.u[i],(A.p,),A.t[i])
 end
-
 function observed(A::AbstractDiffEqArray{T, N},sym,::Colon) where {T, N}
     A.observed.((sym,),A.u,(A.p,),A.t)
 end
-# 
+
 Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, i::Int,::Colon) where {T, N} = [VA.u[j][i] for j in 1:length(VA)]
 Base.@propagate_inbounds function Base.getindex(VA::AbstractVectorOfArray{T,N}, ii::CartesianIndex) where {T, N}
     ti = Tuple(ii)