Revert "formatting"

This reverts commit f4675f2.

Author: jlchan

src/vector_of_array.jl

@@ -29,7 +29,6 @@ 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.
 
 There is also support for `VectorOfArray` constructed from multi-dimensional arrays
-
 ```julia
 VectorOfArray(u::AbstractArray{AT}) where {T, N, AT <: AbstractArray{T, N}}
 ```
@@ -352,53 +351,48 @@ Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::NotSymboli
 end
 
 struct ParameterIndexingError <: Exception
-    sym::Any
+    sym
 end
 
 function Base.showerror(io::IO, pie::ParameterIndexingError)
-    print(io,
-        "Indexing with parameters is deprecated. Use `getp(A, $(pie.sym))` for parameter indexing.")
+    print(io, "Indexing with parameters is deprecated. Use `getp(A, $(pie.sym))` for parameter indexing.")
 end
 
 # Symbolic Indexing Methods
 for (symtype, elsymtype, valtype, errcheck) in [
-    (ScalarSymbolic, SymbolicIndexingInterface.SymbolicTypeTrait,
-        Any, :(is_parameter(A, sym))),
-    (ArraySymbolic, SymbolicIndexingInterface.SymbolicTypeTrait,
-        Any, :(is_parameter(A, sym))),
-    (NotSymbolic, SymbolicIndexingInterface.SymbolicTypeTrait,
-        Union{<:Tuple, <:AbstractArray},
-        :(all(x -> is_parameter(A, x), sym)))
+    (ScalarSymbolic, SymbolicIndexingInterface.SymbolicTypeTrait, Any, :(is_parameter(A, sym))),
+    (ArraySymbolic, SymbolicIndexingInterface.SymbolicTypeTrait, Any, :(is_parameter(A, sym))),
+    (NotSymbolic, SymbolicIndexingInterface.SymbolicTypeTrait, Union{<:Tuple, <:AbstractArray}, 
+        :(all(x -> is_parameter(A, x), sym))),
 ]
-    @eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
-            ::$elsymtype, sym::$valtype)
-        if $errcheck
-            throw(ParameterIndexingError(sym))
-        end
-        getu(A, sym)(A)
+@eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
+        ::$elsymtype, sym::$valtype)
+    if $errcheck
+        throw(ParameterIndexingError(sym))
     end
-    @eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
-            ::$elsymtype, sym::$valtype, arg)
-        if $errcheck
-            throw(ParameterIndexingError(sym))
-        end
-        getu(A, sym)(A, arg)
+    getu(A, sym)(A)
+end
+@eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
+        ::$elsymtype, sym::$valtype, arg)
+    if $errcheck
+        throw(ParameterIndexingError(sym))
     end
-    @eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
-            ::$elsymtype, sym::$valtype, arg::Union{
-                AbstractArray{Int}, AbstractArray{Bool}})
-        if $errcheck
-            throw(ParameterIndexingError(sym))
-        end
-        getu(A, sym).((A,), arg)
+    getu(A, sym)(A, arg)
+end
+@eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
+        ::$elsymtype, sym::$valtype, arg::Union{AbstractArray{Int}, AbstractArray{Bool}})
+    if $errcheck
+        throw(ParameterIndexingError(sym))
     end
-    @eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
-            ::$elsymtype, sym::$valtype, ::Colon)
-        if $errcheck
-            throw(ParameterIndexingError(sym))
-        end
-        getu(A, sym)(A)
+    getu(A, sym).((A,), arg)
+end
+@eval Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::$symtype,
+        ::$elsymtype, sym::$valtype, ::Colon)
+    if $errcheck
+        throw(ParameterIndexingError(sym))
     end
+    getu(A, sym)(A)
+end
 end
 
 Base.@propagate_inbounds function _getindex(A::AbstractDiffEqArray, ::ScalarSymbolic,
@@ -416,9 +410,8 @@ Base.@propagate_inbounds function Base.getindex(A::AbstractVectorOfArray, _arg,
     elsymtype = symbolic_type(eltype(_arg))
 
     if symtype == NotSymbolic() && elsymtype == NotSymbolic()
-        if _arg isa Union{Tuple, AbstractArray} &&
-           any(x -> symbolic_type(x) != NotSymbolic(), _arg)
-            _getindex(A, symtype, elsymtype, _arg, args...)
+        if _arg isa Union{Tuple, AbstractArray} && any(x -> symbolic_type(x) != NotSymbolic(), _arg)
+        _getindex(A, symtype, elsymtype, _arg, args...)
         else
             _getindex(A, symtype, _arg, args...)
         end
@@ -734,6 +727,7 @@ function Base.similar(vec::VectorOfArray{
     return Base.similar(vec, eltype(vec))
 end
 
+
 # fill!
 # For DiffEqArray it ignores ts and fills only u
 function Base.fill!(VA::AbstractVectorOfArray, x)

test/basic_indexing.jl

@@ -248,13 +248,13 @@ function foo!(u)
 end
 foo!(u_matrix)
 foo!(u_vector)
-@test all(u_matrix .== [3, 10])
+@test all(u_matrix .== [3, 10]) 
 @test all(vec(u_matrix) .≈ vec(u_vector))
 
 # test that, for VectorOfArray with multi-dimensional parent arrays,
 # broadcast and `similar` preserve the structure of the parent array
 @test typeof(parent(similar(u_matrix))) == typeof(parent(u_matrix))
-@test typeof(parent((x -> x).(u_matrix))) == typeof(parent(u_matrix))
+@test typeof(parent((x->x).(u_matrix))) == typeof(parent(u_matrix)) 
 
 # test efficiency 
 num_allocs = @allocations foo!(u_matrix)