From c9e5ece5ab146bf761c09383b53d966604f6a16a Mon Sep 17 00:00:00 2001 From: Jack Dunham Date: Tue, 6 Feb 2024 17:08:26 +0000 Subject: [PATCH 1/3] feat: add `AbstractCircularArray` abstract type revert formatting --- src/CircularArrays.jl | 85 +++++++++++++++++++++++-------------------- 1 file changed, 46 insertions(+), 39 deletions(-) diff --git a/src/CircularArrays.jl b/src/CircularArrays.jl index e7bfcf3..ab6835b 100644 --- a/src/CircularArrays.jl +++ b/src/CircularArrays.jl @@ -3,8 +3,53 @@ Arrays with fixed size and circular indexing. """ module CircularArrays +export AbstractCircularArray, AbstractCircularVector, AbstractCircularMatrix export CircularArray, CircularVector, CircularMatrix +abstract type AbstractCircularArray{T,N} <: AbstractArray{T,N} end + +const AbstractCircularVector{T} = AbstractCircularArray{T,1} +const AbstractCircularMatrix{T} = AbstractCircularArray{T,2} + +Base.IndexStyle(::Type{<:AbstractCircularArray}) = IndexCartesian() +Base.IndexStyle(::Type{<:AbstractCircularVector}) = IndexLinear() + +@inline Base.getindex(arr::AbstractCircularArray, i::Int) = @inbounds getindex(parent(arr), mod(i, eachindex(IndexLinear(), parent(arr)))) +@inline Base.getindex(arr::AbstractCircularArray{T,N}, I::Vararg{Int,N}) where {T,N} = @inbounds getindex(parent(arr), mod.(I, axes(parent(arr)))...) + +@inline Base.setindex!(arr::AbstractCircularArray, v, i::Int) = @inbounds setindex!(parent(arr), v, mod(i, eachindex(IndexLinear(), parent(arr)))) +@inline Base.setindex!(arr::AbstractCircularArray{T,N}, v, I::Vararg{Int,N}) where {T,N} = @inbounds setindex!(parent(arr), v, mod.(I, axes(parent(arr)))...) + +@inline Base.size(arr::AbstractCircularArray) = size(parent(arr)) +@inline Base.axes(arr::AbstractCircularArray) = axes(parent(arr)) + +@inline Base.iterate(arr::AbstractCircularArray, i...) = iterate(parent(arr), i...) + +@inline Base.in(x, arr::AbstractCircularArray) = in(x, parent(arr)) + +@inline function Base.checkbounds(arr::AbstractCircularArray, I...) + J = Base.to_indices(arr, I) + length(J) == 1 || length(J) >= ndims(arr) || throw(BoundsError(arr, I)) + nothing +end + +@inline Base.dataids(arr::AbstractCircularArray) = Base.dataids(parent(arr)) + +function Base.deleteat!(a::AbstractCircularVector, i::Integer) + deleteat!(parent(a), mod(i, eachindex(IndexLinear(), parent(a)))) + a +end + +function Base.deleteat!(a::AbstractCircularVector, inds) + deleteat!(parent(a), sort!(unique(map(i -> mod(i, eachindex(IndexLinear(), parent(a))), inds)))) + a +end + +function Base.insert!(a::AbstractCircularVector, i::Integer, item) + insert!(parent(a), mod(i, eachindex(IndexLinear(), parent(a))), item) + a +end + """ CircularArray{T, N, A} <: AbstractArray{T, N} @@ -12,7 +57,7 @@ export CircularArray, CircularVector, CircularMatrix array[index...] == array[mod1.(index, size)...] """ -struct CircularArray{T, N, A <: AbstractArray{T,N}} <: AbstractArray{T,N} +struct CircularArray{T,N,A} <: AbstractCircularArray{T,N} data::A CircularArray{T,N}(data::A) where A <: AbstractArray{T,N} where {T,N} = new{T,N,A}(data) CircularArray{T,N,A}(data::A) where A <: AbstractArray{T,N} where {T,N} = new{T,N,A}(data) @@ -51,30 +96,9 @@ Create a `CircularArray` of size `size` filled with value `def`. """ CircularArray(def::T, size) where T = CircularArray(fill(def, size)) -Base.IndexStyle(::Type{CircularArray{T,N,A}}) where {T,N,A} = IndexCartesian() -Base.IndexStyle(::Type{<:CircularVector}) = IndexLinear() - -@inline Base.getindex(arr::CircularArray, i::Int) = @inbounds getindex(arr.data, mod(i, eachindex(IndexLinear(), arr.data))) -@inline Base.getindex(arr::CircularArray{T,N,A}, I::Vararg{Int,N}) where {T,N,A} = @inbounds getindex(arr.data, mod.(I, axes(arr.data))...) - -@inline Base.setindex!(arr::CircularArray, v, i::Int) = @inbounds setindex!(arr.data, v, mod(i, eachindex(IndexLinear(), arr.data))) -@inline Base.setindex!(arr::CircularArray{T,N,A}, v, I::Vararg{Int,N}) where {T,N,A} = @inbounds setindex!(arr.data, v, mod.(I, axes(arr.data))...) - -@inline Base.size(arr::CircularArray) = size(arr.data) -@inline Base.axes(arr::CircularArray) = axes(arr.data) @inline Base.parent(arr::CircularArray) = arr.data - -@inline Base.iterate(arr::CircularArray, i...) = iterate(parent(arr), i...) - -@inline Base.in(x, arr::CircularArray) = in(x, parent(arr)) @inline Base.copy(arr::CircularArray) = CircularArray(copy(parent(arr))) -@inline function Base.checkbounds(arr::CircularArray, I...) - J = Base.to_indices(arr, I) - length(J) == 1 || length(J) >= ndims(arr) || throw(BoundsError(arr, I)) - nothing -end - @inline _similar(arr::CircularArray, ::Type{T}, dims) where T = CircularArray(similar(parent(arr), T, dims)) @inline Base.similar(arr::CircularArray, ::Type{T}, dims::Tuple{Base.DimOrInd, Vararg{Base.DimOrInd}}) where T = _similar(arr, T, dims) # Ambiguity resolution with Base @@ -90,8 +114,6 @@ end @inline Broadcast.BroadcastStyle(::Type{CircularArray{T,N,A}}) where {T,N,A} = Broadcast.ArrayStyle{CircularArray{T,N,A}}() @inline Base.similar(bc::Broadcast.Broadcasted{Broadcast.ArrayStyle{CircularArray{T,N,A}}}, ::Type{ElType}) where {T,N,A,ElType} = CircularArray(similar(convert(Broadcast.Broadcasted{typeof(Broadcast.BroadcastStyle(A))}, bc), ElType)) -@inline Base.dataids(arr::CircularArray) = Base.dataids(parent(arr)) - function Base.showarg(io::IO, arr::CircularArray, toplevel) print(io, ndims(arr) == 1 ? "CircularVector(" : "CircularArray(") Base.showarg(io, parent(arr), false) @@ -130,19 +152,4 @@ CircularMatrix(def::T, size::NTuple{2, Integer}) where T = CircularMatrix{T}(fil Base.empty(::CircularVector{T}, ::Type{U}=T) where {T,U} = CircularVector{U}(U[]) -function Base.deleteat!(a::CircularVector, i::Integer) - deleteat!(a.data, mod(i, eachindex(IndexLinear(), a.data))) - a -end - -function Base.deleteat!(a::CircularVector, inds) - deleteat!(a.data, sort!(unique(map(i -> mod(i, eachindex(IndexLinear(), a.data)), inds)))) - a -end - -function Base.insert!(a::CircularVector, i::Integer, item) - insert!(a.data, mod(i, eachindex(IndexLinear(), a.data)), item) - a -end - end From d3039e6653fbfe3fedd7f7cbd586df34d869c4a4 Mon Sep 17 00:00:00 2001 From: Jack Dunham Date: Tue, 6 Feb 2024 19:33:05 +0000 Subject: [PATCH 2/3] fix: define method for Base.parent to avoid recursion --- src/CircularArrays.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/CircularArrays.jl b/src/CircularArrays.jl index ab6835b..ffcd230 100644 --- a/src/CircularArrays.jl +++ b/src/CircularArrays.jl @@ -11,6 +11,8 @@ abstract type AbstractCircularArray{T,N} <: AbstractArray{T,N} end const AbstractCircularVector{T} = AbstractCircularArray{T,1} const AbstractCircularMatrix{T} = AbstractCircularArray{T,2} +Base.parent(arg::AbstractCircularArray) = arg.data + Base.IndexStyle(::Type{<:AbstractCircularArray}) = IndexCartesian() Base.IndexStyle(::Type{<:AbstractCircularVector}) = IndexLinear() From 89f76a9cdd6aea5a39bc01a5450c380607da7eac Mon Sep 17 00:00:00 2001 From: Jack Dunham Date: Wed, 21 Feb 2024 13:30:25 +0000 Subject: [PATCH 3/3] test: add basic subtyping tests --- test/runtests.jl | 57 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/test/runtests.jl b/test/runtests.jl index baa1632..17eb3e4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -272,4 +272,61 @@ end @test a[i,1] == CircularArray(OffsetArray([5,6,4,5,6],-2:2)) @test a[CartesianIndex.(i,i)] == CircularArray(OffsetArray([5,9,1,5,9],-2:2)) @test a[a .> 4] == 5:9 +@testset "abstract" begin + struct CustomCircularArray{T, N, A <: AbstractArray{T, N}} <: AbstractCircularArray{T, N} + data::A + end + + @testset "vector" begin + + v = Vector{Int}([3, 6, 9, 12, 15]) + vc = CustomCircularArray(v) + + @test vc isa CustomCircularArray + @test vc isa CustomCircularArray{Int} + @test vc isa CustomCircularArray{Int, 1} + @test vc isa CustomCircularArray{Int, 1, Vector{Int}} + + @test vc isa AbstractCircularArray + @test vc isa AbstractCircularVector + @test vc isa AbstractCircularVector{Int} + @test vc isa AbstractCircularArray{Int} + @test vc isa AbstractCircularArray{Int, 1} + + @test vc isa AbstractArray + @test vc isa AbstractVector + @test vc isa AbstractVector{Int} + @test vc isa AbstractArray{Int} + @test vc isa AbstractArray{Int, 1} + + @test parent(vc) == v + + end + + @testset "matrix" begin + + m = Matrix{Int}([11 12 13; 21 22 23; 31 32 33]) + mc = CustomCircularArray(m) + + @test mc isa CustomCircularArray + @test mc isa CustomCircularArray{Int} + @test mc isa CustomCircularArray{Int, 2} + @test mc isa CustomCircularArray{Int, 2, Matrix{Int}} + + @test mc isa AbstractCircularArray + @test mc isa AbstractCircularMatrix + @test mc isa AbstractCircularMatrix{Int} + @test mc isa AbstractCircularArray{Int} + @test mc isa AbstractCircularArray{Int, 2} + + @test mc isa AbstractArray + @test mc isa AbstractMatrix + @test mc isa AbstractMatrix{Int} + @test mc isa AbstractArray{Int} + @test mc isa AbstractArray{Int, 2} + + @test parent(mc) == m + + end + end