add copy and othe single arg methods to force dispatch on parent type

src/array.jl

@@ -31,6 +31,7 @@ Base.@propagate_inbounds Base.view(A::AbDimArray, I::Vararg{<:StandardIndices})
 Base.convert(::Type{Array{T,N}}, A::AbDimArray{T,N}) where {T,N} = 
     convert(Array{T,N}, parent(A))
 
+Base.copy(A::AbDimArray) = rebuild(A, copy(parent(A)))
 Base.copy!(dst::AbDimArray, src::AbDimArray) = copy!(parent(src), parent(dst))
 
 # Similar. TODO this need a rethink. How do we know what the new dims are?

src/methods.jl

@@ -2,6 +2,7 @@
 for (mod, fname) in ((:Base, :sum), (:Base, :prod), (:Base, :maximum), (:Base, :minimum), (:Statistics, :mean))
     _fname = Symbol('_', fname)
     @eval begin
+        @inline ($mod.$fname)(A::AbDimArray) = ($mod.$fname)(parent(A))
         @inline ($mod.$_fname)(A::AbstractArray, dims::AllDimensions) =
             rebuild(A, ($mod.$_fname)(parent(A), dimnum(A, dims)), reducedims(A, dims))
         @inline ($mod.$_fname)(f, A::AbstractArray, dims::AllDimensions) =
@@ -16,13 +17,15 @@ end
 for fname in (:std, :var)
     _fname = Symbol('_', fname)
     @eval begin
+        @inline (Statistics.$fname)(A::AbDimArray) = (Statistics.$fname)(parent(A))
         @inline (Statistics.$_fname)(A::AbstractArray, corrected::Bool, mean, dims::AllDimensions) =
             rebuild(A, (Statistics.$_fname)(A, corrected, mean, dimnum(A, dims)), reducedims(A, dims))
         @inline (Statistics.$_fname)(A::AbDimArray, corrected::Bool, mean, dims::Union{Int,Base.Dims}) =
             rebuild(A, (Statistics.$_fname)(parent(A), corrected, mean, dims), reducedims(A, dims))
     end
 end
 
+Statistics.median(A::AbDimArray) = Statistics.median(parent(A))
 Statistics._median(A::AbstractArray, dims::AllDimensions) =
     rebuild(A, Statistics._median(parent(A), dimnum(A, dims)), reducedims(A, dims))
 Statistics._median(A::AbDimArray, dims::Union{Int,Base.Dims}) =

test/benchmarks.jl

@@ -85,26 +85,32 @@ println("reverse: normal, numbers + rebuild, dims + rebuild")
 @btime reverse($da; dims=1) 
 @btime reverse($da; dims=Y()) 
 
-# Sparse
-using SparseArrays, Statistics
+# Sparse (and similar specialised arrays)
 
 @dim Var "Variable"
 @dim Obs "Observation"
 
-sparsear = sprand(10000, 10000, 0.1)
-sparsed = DimensionalArray(
-    sparsear,
-    (Var <| ["var$i" for i in 1:10000], Obs <| ["obs$i" for i in 1:10000])
-)
+sparse_a = sprand(1000, 1000, 0.1)
+sparse_d = DimensionalArray(sparse_a, (Var <| 1:1000, Obs <| 1:1000))
 
 # Jit warmups
-mean(sparsear, dims=1)
-mean(sparsear, dims=2)
-mean(sparsed, dims=Var())
-mean(sparsed, dims=Obs())
+mean(sparse_a, dims=1)
+mean(sparse_a, dims=2)
+mean(sparse_d, dims=Var())
+mean(sparse_d, dims=Obs())
 
 # Benchmarks
-println("Regular sparse")
-@btime mean($sparsear, dims=$1)
-println("Dims sparse")
-@btime mean($sparsed, dims=$Var)
+println("mean with dims arge: regular sparse")
+@btime mean($sparse_a, dims=$1)
+println("mean with dims arge: dims sparse")
+@btime mean($sparse_d, dims=$(Var()))
+
+println("mean: regular sparse")
+@btime mean($sparse_a)
+println("mean: dims sparse")
+@btime mean($sparse_d)
+
+println("copy: regular sparse")
+@btime copy($sparse_a)
+println("copy: dims sparse")
+@btime copy($sparse_d)

test/runtests.jl

@@ -1,4 +1,4 @@
-using DimensionalData, Statistics, Test, BenchmarkTools, Unitful
+using DimensionalData, Statistics, Test, BenchmarkTools, Unitful, SparseArrays
 
 using DimensionalData: val, basetype, slicedims, dims2indices, formatdims, 
       @dim, reducedims, dimnum, basetype, X, Y, Z, Time, Forward