Remove version check (#731)

* Remove VERSION checks in source files

* Remove version checks in tests

* Add drop clarification to eachslice docstring for DimArray

Author: felixcremer

benchmarks/benchmarks.jl

@@ -80,17 +80,16 @@ a = rand(5, 4, 3);
 da = DimArray(a, (Y((1u"m", 5u"m")), X(1:4), Ti(1:3)))
 dimz = dims(da)
 
-if VERSION > v"1.1-"
-    suite["eachslice"] = BenchmarkGroup()
-    suite["eachslice"]["array_intdim"] = @benchmarkable (()->eachslice($a; dims = 2))();
-    suite["eachslice"]["dimarray_intdim"] = @benchmarkable (()->eachslice($da; dims = 2))();
-    suite["eachslice"]["dimarray_dim"] = @benchmarkable (()->eachslice($da; dims = Y()))();
-    suite["eachslice_to_vector"] = BenchmarkGroup()
-    suite["eachslice_to_vector"]["array_intdim"] = @benchmarkable [slice for slice in eachslice($a; dims = 2)];
-    suite["eachslice_to_vector"]["dimarray_intdim"] = @benchmarkable [slice for slice in eachslice($da; dims = 2)];
-    suite["eachslice_to_vector"]["dimarray_dim"] = @benchmarkable [slice for slice in eachslice($da; dims = X())];
-    # @test [slice for slice in eachslice(da; dims=1)] == [slice for slice in eachslice(da; dims=Y)]
-end
+suite["eachslice"] = BenchmarkGroup()
+suite["eachslice"]["array_intdim"] = @benchmarkable (()->eachslice($a; dims = 2))();
+suite["eachslice"]["dimarray_intdim"] = @benchmarkable (()->eachslice($da; dims = 2))();
+suite["eachslice"]["dimarray_dim"] = @benchmarkable (()->eachslice($da; dims = Y()))();
+suite["eachslice_to_vector"] = BenchmarkGroup()
+suite["eachslice_to_vector"]["array_intdim"] = @benchmarkable [slice for slice in eachslice($a; dims = 2)];
+suite["eachslice_to_vector"]["dimarray_intdim"] = @benchmarkable [slice for slice in eachslice($da; dims = 2)];
+suite["eachslice_to_vector"]["dimarray_dim"] = @benchmarkable [slice for slice in eachslice($da; dims = X())];
+# @test [slice for slice in eachslice(da; dims=1)] == [slice for slice in eachslice(da; dims=Y)]
+
 
 
 suite["mean"] = BenchmarkGroup()

src/Dimensions/dimunitrange.jl

@@ -25,26 +25,13 @@ for f in [:length, :isempty, :first, :last]
     @eval @inline Base.$f(r::DimUnitRange) = Base.$f(parent(r))
 end
 @inline Base.axes(r::DimUnitRange) = (r,)
-if VERSION < v"1.8.2"
-    # On recent Julia versions, these don't need to be defined, and defining them may
-    # increase validations, see https://github.com/JuliaArrays/OffsetArrays.jl/pull/311
-    Base.axes1(r::DimUnitRange) = r
-    for f in [:firstindex, :lastindex]
-        @eval @inline Base.$f(r::DimUnitRange) = $f(parent(r))
-    end
-end
 @inline Base.iterate(r::DimUnitRange, i...) = iterate(parent(r), i...)
 @inline Base.getindex(r::DimUnitRange, i::Integer) = getindex(parent(r), i)
 
 # Conversions to an AbstractUnitRange{Int} (and to an OrdinalRange{Int,Int} on Julia v"1.6") are necessary
 # to evaluate CartesianIndices for BigInt ranges, as their axes are also BigInt ranges
 Base.AbstractUnitRange{T}(r::DimUnitRange) where {T<:Integer} = DimUnitRange{T}(r)
 
-# https://github.com/JuliaLang/julia/pull/40038
-if v"1.6" <= VERSION < v"1.9.0-DEV.642"
-    Base.OrdinalRange{T,T}(r::DimUnitRange) where {T<:Integer} = DimUnitRange{T}(r)
-end
-
 @inline function Base.checkindex(::Type{Bool}, r::DimUnitRange, i::Real)
     return Base.checkindex(Bool, parent(r), i)
 end

src/array/array.jl

@@ -287,31 +287,30 @@ for (d, s) in ((:AbstractDimArray, :AbstractDimArray),
     end
 end
 # Ambiguity
-@static if VERSION >= v"1.9.0"
-    Base.copyto!(dst::AbstractDimArray{T,2}, src::SparseArrays.CHOLMOD.Dense{T}) where T<:Union{Float64,ComplexF64} =
-        (copyto!(parent(dst), src); dst)
-    Base.copyto!(dst::AbstractDimArray{T}, src::SparseArrays.CHOLMOD.Dense{T}) where T<:Union{Float64,ComplexF64} =
-        (copyto!(parent(dst), src); dst)
-    Base.copyto!(dst::DimensionalData.AbstractDimArray, src::SparseArrays.CHOLMOD.Dense) =
-        (copyto!(parent(dst), src); dst)
-    Base.copyto!(dst::SparseArrays.AbstractCompressedVector, src::AbstractDimArray{T, 1} where T) =
-        (copyto!(dst, parent(src)); dst)
-    Base.copyto!(dst::AbstractDimArray{T,2} where T, src::SparseArrays.AbstractSparseMatrixCSC) =
-        (copyto!(parent(dst), src); dst)
-    Base.copyto!(dst::AbstractDimArray{T,2} where T, src::LinearAlgebra.AbstractQ) =
-        (copyto!(parent(dst), src); dst)
-    function Base.copyto!(
-        dst::AbstractDimArray{<:Any,2}, 
-        dst_i::CartesianIndices{2, R} where R<:Tuple{OrdinalRange{Int64, Int64}, OrdinalRange{Int64, Int64}}, 
-        src::SparseArrays.AbstractSparseMatrixCSC{<:Any}, 
-        src_i::CartesianIndices{2, R} where R<:Tuple{OrdinalRange{Int64, Int64}, OrdinalRange{Int64, Int64}}
-    )
-        copyto!(parent(dst), dst_i, src, src_i)
-        return dst
-    end
-    Base.copy!(dst::SparseArrays.AbstractCompressedVector{T}, src::AbstractDimArray{T, 1}) where T =
-        (copy!(dst, parent(src)); dst)
+Base.copyto!(dst::AbstractDimArray{T,2}, src::SparseArrays.CHOLMOD.Dense{T}) where T<:Union{Float64,ComplexF64} =
+    (copyto!(parent(dst), src); dst)
+Base.copyto!(dst::AbstractDimArray{T}, src::SparseArrays.CHOLMOD.Dense{T}) where T<:Union{Float64,ComplexF64} =
+    (copyto!(parent(dst), src); dst)
+Base.copyto!(dst::DimensionalData.AbstractDimArray, src::SparseArrays.CHOLMOD.Dense) =
+    (copyto!(parent(dst), src); dst)
+Base.copyto!(dst::SparseArrays.AbstractCompressedVector, src::AbstractDimArray{T, 1} where T) =
+    (copyto!(dst, parent(src)); dst)
+Base.copyto!(dst::AbstractDimArray{T,2} where T, src::SparseArrays.AbstractSparseMatrixCSC) =
+    (copyto!(parent(dst), src); dst)
+Base.copyto!(dst::AbstractDimArray{T,2} where T, src::LinearAlgebra.AbstractQ) =
+    (copyto!(parent(dst), src); dst)
+function Base.copyto!(
+    dst::AbstractDimArray{<:Any,2}, 
+    dst_i::CartesianIndices{2, R} where R<:Tuple{OrdinalRange{Int64, Int64}, OrdinalRange{Int64, Int64}}, 
+    src::SparseArrays.AbstractSparseMatrixCSC{<:Any}, 
+    src_i::CartesianIndices{2, R} where R<:Tuple{OrdinalRange{Int64, Int64}, OrdinalRange{Int64, Int64}}
+)
+    copyto!(parent(dst), dst_i, src, src_i)
+    return dst
 end
+Base.copy!(dst::SparseArrays.AbstractCompressedVector{T}, src::AbstractDimArray{T, 1}) where T =
+    (copy!(dst, parent(src)); dst)
+
 Base.copy!(dst::SparseArrays.SparseVector, src::AbstractDimArray{T,1}) where T =
     (copy!(dst, parent(src)); dst)
 Base.copyto!(dst::PermutedDimsArray, src::AbstractDimArray) = 

src/array/methods.jl

@@ -67,15 +67,14 @@ function Base._mapreduce_dim(f, op, nt, A::AbstractDimArray, dims::Colon)
     rebuild(A, Base._mapreduce_dim(f, op, nt, parent(A), dimnum(A, dims)), reducedims(A, dims))
 end
 
-@static if VERSION >= v"1.6"
-    function Base._mapreduce_dim(f, op, nt::Base._InitialValue, A::AbstractDimArray, dims)
-        rebuild(A, Base._mapreduce_dim(f, op, nt, parent(A), dimnum(A, dims)), reducedims(A, dims))
-    end
-    function Base._mapreduce_dim(f, op, nt::Base._InitialValue, A::AbstractDimArray, dims::Colon)
-        Base._mapreduce_dim(f, op, nt, parent(A), dims)
-    end
+function Base._mapreduce_dim(f, op, nt::Base._InitialValue, A::AbstractDimArray, dims)
+    rebuild(A, Base._mapreduce_dim(f, op, nt, parent(A), dimnum(A, dims)), reducedims(A, dims))
+end
+function Base._mapreduce_dim(f, op, nt::Base._InitialValue, A::AbstractDimArray, dims::Colon)
+    Base._mapreduce_dim(f, op, nt, parent(A), dims)
 end
 
+
 # TODO: Unfortunately Base/accumulate.jl kw methods all force dims to be Integer.
 # accumulate wont work unless that is relaxed, or we copy half of the file here.
 # Base._accumulate!(op, B, A, dims::AllDims, init::Union{Nothing, Some}) =
@@ -120,51 +119,43 @@ end
     return rebuild(A, newdata, newdims)
 end
 
-@static if VERSION < v"1.9-alpha1"
-    """
-        Base.eachslice(A::AbstractDimArray; dims)
+"""
+    Base.eachslice(A::AbstractDimArray; dims,drop=true)
 
-    Create a generator that iterates over dimensions `dims` of `A`, returning arrays that
-    select all the data from the other dimensions in `A` using views.
+Create a generator that iterates over dimensions `dims` of `A`, returning arrays that
+select all the data from the other dimensions in `A` using views.
 
-    The generator has `size` and `axes` equivalent to those of the provided `dims`.
-    """
-    function Base.eachslice(A::AbstractDimArray; dims)
-        dimtuple = _astuple(dims)
-        if !(dimtuple == ()) 
-            all(hasdim(A, dimtuple...)) || throw(DimensionMismatch("A doesn't have all dimensions $dims"))
-        end
-        _eachslice(A, dimtuple)
+The generator has `size` and `axes` equivalent to those of the provided `dims` if `drop=true`.
+Otherwise it will have the same dimensionality as the underlying array with inner dimensions having size 1.
+"""
+@inline function Base.eachslice(A::AbstractDimArray; dims, drop=true)
+    dimtuple = _astuple(dims)
+    if !(dimtuple == ()) 
+        all(hasdim(A, dimtuple...)) || throw(DimensionMismatch("A doesn't have all dimensions $dims"))
     end
-else
-    @inline function Base.eachslice(A::AbstractDimArray; dims, drop=true)
-        dimtuple = _astuple(dims)
-        if !(dimtuple == ()) 
-            all(hasdim(A, dimtuple...)) || throw(DimensionMismatch("A doesn't have all dimensions $dims"))
+    _eachslice(A, dimtuple, drop)
+end
+Base.@constprop :aggressive function _eachslice(A::AbstractDimArray{T,N}, dims, drop) where {T,N}
+    slicedims = Dimensions.dims(A, dims)
+    Adims = Dimensions.dims(A)
+    if drop
+        ax = map(dim -> axes(A, dim), slicedims)
+        slicemap = map(Adims) do dim
+            hasdim(slicedims, dim) ? dimnum(slicedims, dim) : (:)
         end
-        _eachslice(A, dimtuple, drop)
-    end
-    Base.@constprop :aggressive function _eachslice(A::AbstractDimArray{T,N}, dims, drop) where {T,N}
-        slicedims = Dimensions.dims(A, dims)
-        Adims = Dimensions.dims(A)
-        if drop
-            ax = map(dim -> axes(A, dim), slicedims)
-            slicemap = map(Adims) do dim
-                hasdim(slicedims, dim) ? dimnum(slicedims, dim) : (:)
-            end
-            return Slices(A, slicemap, ax)
-        else
-            ax = map(Adims) do dim
-                hasdim(slicedims, dim) ? axes(A, dim) : axes(reducedims(dim, dim), 1)
-            end
-            slicemap = map(Adims) do dim
-                hasdim(slicedims, dim) ? dimnum(A, dim) : (:)
-            end
-            return Slices(A, slicemap, ax)
+        return Slices(A, slicemap, ax)
+    else
+        ax = map(Adims) do dim
+            hasdim(slicedims, dim) ? axes(A, dim) : axes(reducedims(dim, dim), 1)
         end
+        slicemap = map(Adims) do dim
+            hasdim(slicedims, dim) ? dimnum(A, dim) : (:)
+        end
+        return Slices(A, slicemap, ax)
     end
 end
 
+
 # works for arrays and for stacks
 function _eachslice(x, dims::Tuple)
     slicedims = Dimensions.dims(x, dims)

src/stack/methods.jl

@@ -47,7 +47,7 @@ function Base.copyto!(
 end
 
 """
-    Base.eachslice(stack::AbstractDimStack; dims)
+    Base.eachslice(stack::AbstractDimStack; dims, drop=true)
 
 Create a generator that iterates over dimensions `dims` of `stack`, returning stacks that
 select all the data from the other dimensions in `stack` using views.
@@ -80,26 +80,19 @@ and 2 layers:
   :y Float64 dims: Y, Ti (3×5)
 ```
 """
-@static if VERSION < v"1.9-alpha1"
-    function Base.eachslice(s::AbstractDimStack; dims)
-        dimtuple = _astuple(basedims(dims))
-        all(hasdim(s, dimtuple)) || throw(DimensionMismatch("s doesn't have all dimensions $dims"))
-        _eachslice(s, dimtuple)
+function Base.eachslice(s::AbstractDimStack; dims, drop=true)
+    dimtuple = _astuple(dims)
+    if !(dimtuple == ()) 
+        all(hasdim(s, dimtuple)) || throw(DimensionMismatch("A doesn't have all dimensions $dims"))
     end
-else
-    function Base.eachslice(s::AbstractDimStack; dims, drop=true)
-        dimtuple = _astuple(dims)
-        if !(dimtuple == ()) 
-            all(hasdim(s, dimtuple)) || throw(DimensionMismatch("A doesn't have all dimensions $dims"))
-        end
-        # Avoid getting DimUnitRange from `axes(s)`
-        axisdims = map(DD.dims(s, dimtuple)) do d
-            rebuild(d, axes(lookup(d), 1)) 
-        end
-        return DimSlices(s; dims=axisdims, drop)
+    # Avoid getting DimUnitRange from `axes(s)`
+    axisdims = map(DD.dims(s, dimtuple)) do d
+        rebuild(d, axes(lookup(d), 1)) 
     end
+    return DimSlices(s; dims=axisdims, drop)
 end
 
+
 """
     Base.cat(stacks::AbstractDimStack...; [keys=keys(stacks[1])], dims)
 

test/array.jl

@@ -367,34 +367,32 @@ end
     @test convert(DimArray{eltype(da)}, da) === convert(DimArray, da) === da
 end
 
-if VERSION > v"1.1-"
-    @testset "copy!" begin
-        dimz = dims(da2)
-        A = zero(a2)
-        sp = sprand(Int, 4, 0.5)
-        db = DimArray(deepcopy(A), dimz)
-        dc = DimArray(deepcopy(A), dimz)
-
-        @test copy!(A, da2) isa Matrix
-        @test A == parent(da2)
-        @test copy!(db, da2) isa DimMatrix
-        @test parent(db) == parent(da2)
-        @test copy!(dc, a2) isa DimMatrix
-        @test parent(db) == a2
-        # Sparse vector has its own method for ambiguity
-        copy!(sp, da2[1, :])
-        @test sp == parent(da2[1, :])
-
-        @testset "vector copy! (ambiguity fix)" begin
-            v = zeros(3)
-            dv = DimArray(zeros(3), X)
-            @test copy!(v, DimArray([1.0, 2.0, 3.0], X)) isa Vector
-            @test v == [1.0, 2.0, 3.0]
-            @test copy!(dv, DimArray([9.9, 9.9, 9.9], X)) isa DimVector
-            @test dv == [9.9, 9.9, 9.9]
-            @test copy!(dv, [5.0, 5.0, 5.0]) isa DimVector
-            @test dv == [5.0, 5.0, 5.0]
-        end
+@testset "copy!" begin
+    dimz = dims(da2)
+    A = zero(a2)
+    sp = sprand(Int, 4, 0.5)
+    db = DimArray(deepcopy(A), dimz)
+    dc = DimArray(deepcopy(A), dimz)
+
+    @test copy!(A, da2) isa Matrix
+    @test A == parent(da2)
+    @test copy!(db, da2) isa DimMatrix
+    @test parent(db) == parent(da2)
+    @test copy!(dc, a2) isa DimMatrix
+    @test parent(db) == a2
+    # Sparse vector has its own method for ambiguity
+    copy!(sp, da2[1, :])
+    @test sp == parent(da2[1, :])
+
+    @testset "vector copy! (ambiguity fix)" begin
+        v = zeros(3)
+        dv = DimArray(zeros(3), X)
+        @test copy!(v, DimArray([1.0, 2.0, 3.0], X)) isa Vector
+        @test v == [1.0, 2.0, 3.0]
+        @test copy!(dv, DimArray([9.9, 9.9, 9.9], X)) isa DimVector
+        @test dv == [9.9, 9.9, 9.9]
+        @test copy!(dv, [5.0, 5.0, 5.0]) isa DimVector
+        @test dv == [5.0, 5.0, 5.0]
     end
 end
 

test/dimunitrange.jl

@@ -22,10 +22,6 @@ axdims = [
     @test axes(r) === (r,)
     @test axes(r, 1) === r
     @test Base.axes1(r) === r
-    if VERSION < v"1.8.2"
-        @test firstindex(r) == firstindex(ax)
-        @test lastindex(r) == lastindex(ax)
-    end
     @test iterate(r) === iterate(ax)
     @test iterate(r, iterate(r)[2]) === iterate(ax, iterate(r)[2])
     @test r[begin] == ax[begin]
@@ -38,9 +34,7 @@ axdims = [
     @test dims(bigr) === dim
     @test bigr == ax
     @test DimUnitRange{eltype(r)}(r) === r
-    if VERSION >= v"1.6"
-        @test Base.OrdinalRange{Int,Int}(r) == r
-    end
+    @test Base.OrdinalRange{Int,Int}(r) == r
     @test AbstractUnitRange{BigInt}(r) isa DimUnitRange{BigInt}
     @test parent(AbstractUnitRange{BigInt}(r)) == AbstractUnitRange{BigInt}(parent(r))
     @test dims(AbstractUnitRange{BigInt}(r)) === dim

test/indexing.jl

@@ -467,13 +467,12 @@ end
         @inferred setindex!(da2_set, 77, Dim{:row}(1), column=2)
 
         # With a large type
-        if VERSION >= v"1.5"
-            da4 = DimArray(zeros(1, 2, 3, 4, 5, 6, 7, 8), (:a, :b, :c, :d, :d, :f, :g, :h))
-            @inferred getindex(da2, a=1, b=2, c=3, d=4, e=5)
-            # Type inference breaks with 6 arguments.
-            # @inferred getindex(da2, a=1, b=2, c=3, d=4, e=5, f=6)
-            # @code_warntype getindex(da2, a=1, b=2, c=3, d=4, e=5, f=6)
-        end
+        da4 = DimArray(zeros(1, 2, 3, 4, 5, 6, 7, 8), (:a, :b, :c, :d, :d, :f, :g, :h))
+        @inferred getindex(da2, a=1, b=2, c=3, d=4, e=5)
+        # Type inference breaks with 6 arguments.
+        # @inferred getindex(da2, a=1, b=2, c=3, d=4, e=5, f=6)
+        # @code_warntype getindex(da2, a=1, b=2, c=3, d=4, e=5, f=6)
+    
     end
 
     @testset "trailing colon" begin