readded tests for ComposedBoundaryPaddedArray, added CartesianIndex getindex for padded arrays

Author: xtalax

src/boundary_padded_arrays.jl

@@ -27,7 +27,7 @@ end
 Higher dimensional generalization of BoundaryPaddedVector, pads an array of dimension N along the dimension D with 2 Arrays of dimension N-1, stored in lower and upper
 
 """
-struct BoundaryPaddedArray{T<:Number, D, N, M, V<:AbstractArray{T, N}, B<: AbstractArray{T, M}} <: AbstractBoundaryPaddedArray{T,N}
+struct BoundaryPaddedArray{T, D, N, M, V<:AbstractArray{T, N}, B<: AbstractArray{T, M}} <: AbstractBoundaryPaddedArray{T,N}
     lower::B #an array of dimension M = N-1, used to extend the lower index boundary
     upper::B #Ditto for the upper index boundary
     u::V
@@ -71,7 +71,7 @@ end
 
 # Composed BoundaryPaddedArray
 
-struct ComposedBoundaryPaddedArray{T<:Number, N, M, V<:AbstractArray{T, N}, B<: AbstractArray{T, M}} <: AbstractBoundaryPaddedArray{T, N}
+struct ComposedBoundaryPaddedArray{T, N, M, V<:AbstractArray{T, N}, B<: AbstractArray{T, M}} <: AbstractBoundaryPaddedArray{T, N}
     lower::Vector{B}
     upper::Vector{B}
     u::V
@@ -107,7 +107,7 @@ Base.ndims(Q::AbstractBoundaryPaddedArray{T,N}) where {T,N} = N
 add_dim(A::AbstractArray, i) = reshape(A, size(A)...,i)
 add_dim(i) = i
 
-function Base.getindex(Q::BoundaryPaddedArray{T,D,N,M,V,B}, _inds...) where {T,D,N,M,V,B} #supports range and colon indexing!
+function Base.getindex(Q::BoundaryPaddedArray{T,D,N,M,V,B}, _inds::NTuple{N,Int64}...) where {T,D,N,M,V,B} #supports range and colon indexing!
     inds = [_inds...]
     S = size(Q)
     dim = D
@@ -131,10 +131,8 @@ function Base.getindex(Q::BoundaryPaddedArray{T,D,N,M,V,B}, _inds...) where {T,D
     end
 end
 
-function Base.getindex(Q::ComposedBoundaryPaddedArray, inds...) #as yet no support for range indexing or colon indexing
+function Base.getindex(Q::ComposedBoundaryPaddedArray{T, N, M, V, B} , inds::NTuple{N, Int64}...) where {T, N, M, V, B} #as yet no support for range indexing or colon indexing
     S = size(Q)
-    T = gettype(Q)
-    N = ndims(Q)
     @assert reduce((&), inds .<= S)
     for (dim, index) in enumerate(inds)
         if index == 1
@@ -155,3 +153,5 @@ function Base.getindex(Q::ComposedBoundaryPaddedArray, inds...) #as yet no suppo
      end
     return Q.u[(inds.-1)...]
 end
+
+getindex(A::AbstractBoundaryPaddedArray{T,N}, I::CartesianIndex{N}) where {T,N} = A[Tuple(I)...]

test/boundary_padded_array.jl

@@ -14,8 +14,51 @@ for dimensionality in 2:5
 
         @test A == Array(Apad) #test Concretization of BoundaryPaddedMatrix
 
-        for I in CartesianIndeces(A)  #test getindex for all indicies of Apad
+        for I in CartesianIndices(A)  #test getindex for all indicies of Apad
             @test A[I] == Apad[I]
         end
     end
 end
+
+################################################################################
+# Test ComposedBoundaryPaddedMatrix
+################################################################################
+
+n = 10
+m = 21
+A = rand(n,m)
+A[1,1] = A[end,1] = A[1,end] = A[end,end] = 0.0
+
+lower = Vector[A[1,2:(end-1)], A[2:(end-1),1]]
+upper = Vector[A[end,2:(end-1)], A[2:(end-1),end]]
+
+Apad = ComposedBoundaryPaddedMatrix{Float64, typeof(A), typeof(lower[1])}(lower, upper, A[2:(end-1), 2:(end-1)])
+
+@test A == Array(Apad) #test Concretization of BoundaryPaddedMatrix
+
+for i in 1:n, j in 1:m #test getindex for all indicies of Apad
+    @test A[i,j] == Apad[i,j]
+end
+
+################################################################################
+# Test ComposedBoundaryPaddedTensor{3}
+################################################################################
+
+n = 10
+m = 12
+o = 7
+A = rand(n,m,o)
+A[1,1,:] = A[end,1, :] = A[1,end, :] = A[end,end, :] = 0.0
+A[1,:,1] = A[end, :, 1] = A[1,:,end] = A[end,:,end] = 0.0
+A[:,1,1] = A[:,end,1] = A[:,1,end] = A[:,end,end] = 0.0
+
+lower = Matrix[A[1,2:(end-1), 2:(end-1)], A[2:(end-1),1, 2:(end-1)] A[2:(end-1), 2:(end-1), 1]]
+upper = Matrix[A[end, 2:(end-1), 2:(end-1)], A[2:(end-1), end, 2:(end-1)] A[2:(end-1), 2:(end-1), end]]
+
+Apad = BoundaryPadded3Tensor{Float64, typeof(A), typeof(lower[1])}(lower, upper, A[2:(end-1), 2:(end-1), 2:(end-1)])
+
+@test A == Array(Apad) #test Concretization of BoundaryPaddedMatrix
+
+for I in CartesianIndices(A) #test getindex for all indicies of Apad
+    @test A[I] == Apad[I]
+end