Merge branch 'master' into dsptests

Author: jishnub

.github/workflows/downstream.yml

@@ -40,7 +40,6 @@ jobs:
           - {repo: ArrayLayouts.jl, group: JuliaLinearAlgebra}
           - {repo: LazyBandedMatrices.jl, group: JuliaLinearAlgebra}
           - {repo: BandedMatrices.jl, group: JuliaLinearAlgebra}
-          - {repo: ContinuumArrays.jl, group: JuliaApproximation}
           - {repo: BlockBandedMatrices.jl, group: JuliaLinearAlgebra}
           - {repo: InfiniteLinearAlgebra.jl, group: JuliaLinearAlgebra}
           - {repo: Optim.jl, group: JuliaNLSolvers}

Project.toml

@@ -1,13 +1,21 @@
 name = "FillArrays"
 uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
-version = "1.5.0"
+version = "1.6.1"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
+[weakdeps]
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+
+[extensions]
+FillArraysSparseArraysExt = "SparseArrays"
+FillArraysStatisticsExt = "Statistics"
+
 [compat]
 Aqua = "0.5, 0.6"
 DSP = "0.7"
@@ -18,8 +26,9 @@ Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
 ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
-[targets]
-test = ["Aqua", "Test", "Base64", "DSP", "ReverseDiff", "StaticArrays"]
+test = ["Aqua", "Test", "Base64", "ReverseDiff", "SparseArrays", "StaticArrays", "Statistics", "DSP"]

ext/FillArraysSparseArraysExt.jl

@@ -0,0 +1,59 @@
+module FillArraysSparseArraysExt
+
+using SparseArrays
+import Base: convert, kron
+using FillArrays
+using FillArrays: RectDiagonalFill, RectOrDiagonalFill, ZerosVector, ZerosMatrix, getindex_value
+using LinearAlgebra
+
+##################
+## Sparse arrays
+##################
+SparseVector{T}(Z::ZerosVector) where T = spzeros(T, length(Z))
+SparseVector{Tv,Ti}(Z::ZerosVector) where {Tv,Ti} = spzeros(Tv, Ti, length(Z))
+
+convert(::Type{AbstractSparseVector}, Z::ZerosVector{T}) where T = spzeros(T, length(Z))
+convert(::Type{AbstractSparseVector{T}}, Z::ZerosVector) where T= spzeros(T, length(Z))
+
+SparseMatrixCSC{T}(Z::ZerosMatrix) where T = spzeros(T, size(Z)...)
+SparseMatrixCSC{Tv,Ti}(Z::Zeros{T,2,Axes}) where {Tv,Ti<:Integer,T,Axes} = spzeros(Tv, Ti, size(Z)...)
+
+convert(::Type{AbstractSparseMatrix}, Z::ZerosMatrix{T}) where T = spzeros(T, size(Z)...)
+convert(::Type{AbstractSparseMatrix{T}}, Z::ZerosMatrix) where T = spzeros(T, size(Z)...)
+
+convert(::Type{AbstractSparseArray}, Z::Zeros{T}) where T = spzeros(T, size(Z)...)
+convert(::Type{AbstractSparseArray{Tv}}, Z::Zeros{T}) where {T,Tv} = spzeros(Tv, size(Z)...)
+convert(::Type{AbstractSparseArray{Tv,Ti}}, Z::Zeros{T}) where {T,Tv,Ti} = spzeros(Tv, Ti, size(Z)...)
+convert(::Type{AbstractSparseArray{Tv,Ti,N}}, Z::Zeros{T,N}) where {T,Tv,Ti,N} = spzeros(Tv, Ti, size(Z)...)
+
+SparseMatrixCSC{Tv}(Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
+# works around missing `speye`:
+SparseMatrixCSC{Tv,Ti}(Z::Eye{T}) where {T,Tv,Ti<:Integer} =
+    convert(SparseMatrixCSC{Tv,Ti}, SparseMatrixCSC{Tv}(I, size(Z)...))
+
+convert(::Type{AbstractSparseMatrix}, Z::Eye{T}) where {T} = SparseMatrixCSC{T}(I, size(Z)...)
+convert(::Type{AbstractSparseMatrix{Tv}}, Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
+
+convert(::Type{AbstractSparseArray}, Z::Eye{T}) where T = SparseMatrixCSC{T}(I, size(Z)...)
+convert(::Type{AbstractSparseArray{Tv}}, Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
+
+
+convert(::Type{AbstractSparseArray{Tv,Ti}}, Z::Eye{T}) where {T,Tv,Ti} =
+    convert(SparseMatrixCSC{Tv,Ti}, Z)
+convert(::Type{AbstractSparseArray{Tv,Ti,2}}, Z::Eye{T}) where {T,Tv,Ti} =
+    convert(SparseMatrixCSC{Tv,Ti}, Z)
+
+function SparseMatrixCSC{Tv}(R::RectOrDiagonalFill) where {Tv}
+    SparseMatrixCSC{Tv,eltype(axes(R,1))}(R)
+end
+function SparseMatrixCSC{Tv,Ti}(R::RectOrDiagonalFill) where {Tv,Ti}
+    Base.require_one_based_indexing(R)
+    v = parent(R)
+    J = getindex_value(v)*I
+    SparseMatrixCSC{Tv,Ti}(J, size(R))
+end
+
+# TODO: remove in v2.0
+@deprecate kron(E1::RectDiagonalFill, E2::RectDiagonalFill) kron(sparse(E1), sparse(E2))
+
+end # module

ext/FillArraysStatisticsExt.jl

@@ -0,0 +1,33 @@
+module FillArraysStatisticsExt
+
+import Statistics: mean, var, cov, cor
+using LinearAlgebra: diagind
+
+using FillArrays
+using FillArrays: AbstractFill, AbstractFillVector, AbstractFillMatrix, getindex_value
+
+mean(A::AbstractFill; dims=(:)) = mean(identity, A; dims=dims)
+function mean(f::Union{Function, Type}, A::AbstractFill; dims=(:))
+    val = float(f(getindex_value(A)))
+    dims isa Colon ? val :
+        Fill(val, ntuple(d -> d in dims ? 1 : size(A,d), ndims(A))...)
+end
+
+
+function var(A::AbstractFill{T}; corrected::Bool=true, mean=nothing, dims=(:)) where {T<:Number}
+    dims isa Colon ? zero(float(T)) :
+        Zeros{float(T)}(ntuple(d -> d in dims ? 1 : size(A,d), ndims(A))...)
+end
+
+cov(::AbstractFillVector{T}; corrected::Bool=true) where {T<:Number} = zero(float(T))
+cov(A::AbstractFillMatrix{T}; corrected::Bool=true, dims::Integer=1) where {T<:Number} =
+    Zeros{float(T)}(size(A, 3-dims), size(A, 3-dims))
+
+cor(::AbstractFillVector{T}) where {T<:Number} = one(float(T))
+function cor(A::AbstractFillMatrix{T}; dims::Integer=1) where {T<:Number}
+    out = fill(float(T)(NaN), size(A, 3-dims), size(A, 3-dims))
+    out[diagind(out)] .= 1
+    out
+end
+
+end # module

src/FillArrays.jl

@@ -1,7 +1,7 @@
 """ `FillArrays` module to lazily represent matrices with a single value """
 module FillArrays
 
-using LinearAlgebra, SparseArrays, Statistics
+using LinearAlgebra
 import Base: size, getindex, setindex!, IndexStyle, checkbounds, convert,
     +, -, *, /, \, diff, sum, cumsum, maximum, minimum, sort, sort!,
     any, all, axes, isone, iterate, unique, allunique, permutedims, inv,
@@ -16,9 +16,6 @@ import LinearAlgebra: rank, svdvals!, tril, triu, tril!, triu!, diag, transpose,
 
 import Base.Broadcast: broadcasted, DefaultArrayStyle, broadcast_shape, BroadcastStyle, Broadcasted
 
-import Statistics: mean, std, var, cov, cor
-
-
 export Zeros, Ones, Fill, Eye, Trues, Falses, OneElement
 
 import Base: oneto
@@ -530,6 +527,9 @@ function convert(::Type{T}, A::AbstractFillMatrix) where T<:Diagonal
     isdiag(A) ? T(A) : throw(InexactError(:convert, T, A))
 end
 
+Base.StepRangeLen(F::AbstractFillVector{T}) where T = StepRangeLen(getindex_value(F), zero(T), length(F))
+convert(::Type{SL}, F::AbstractFillVector) where SL<:AbstractRange = convert(SL, StepRangeLen(F))
+
 #################
 # Structured matrix types
 #################
@@ -542,52 +542,6 @@ for SMT in (:Diagonal, :Bidiagonal, :Tridiagonal, :SymTridiagonal)
     end
 end
 
-##################
-## Sparse arrays
-##################
-SparseVector{T}(Z::ZerosVector) where T = spzeros(T, length(Z))
-SparseVector{Tv,Ti}(Z::ZerosVector) where {Tv,Ti} = spzeros(Tv, Ti, length(Z))
-
-convert(::Type{AbstractSparseVector}, Z::ZerosVector{T}) where T = spzeros(T, length(Z))
-convert(::Type{AbstractSparseVector{T}}, Z::ZerosVector) where T= spzeros(T, length(Z))
-
-SparseMatrixCSC{T}(Z::ZerosMatrix) where T = spzeros(T, size(Z)...)
-SparseMatrixCSC{Tv,Ti}(Z::Zeros{T,2,Axes}) where {Tv,Ti<:Integer,T,Axes} = spzeros(Tv, Ti, size(Z)...)
-
-convert(::Type{AbstractSparseMatrix}, Z::ZerosMatrix{T}) where T = spzeros(T, size(Z)...)
-convert(::Type{AbstractSparseMatrix{T}}, Z::ZerosMatrix) where T = spzeros(T, size(Z)...)
-
-convert(::Type{AbstractSparseArray}, Z::Zeros{T}) where T = spzeros(T, size(Z)...)
-convert(::Type{AbstractSparseArray{Tv}}, Z::Zeros{T}) where {T,Tv} = spzeros(Tv, size(Z)...)
-convert(::Type{AbstractSparseArray{Tv,Ti}}, Z::Zeros{T}) where {T,Tv,Ti} = spzeros(Tv, Ti, size(Z)...)
-convert(::Type{AbstractSparseArray{Tv,Ti,N}}, Z::Zeros{T,N}) where {T,Tv,Ti,N} = spzeros(Tv, Ti, size(Z)...)
-
-SparseMatrixCSC{Tv}(Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
-# works around missing `speye`:
-SparseMatrixCSC{Tv,Ti}(Z::Eye{T}) where {T,Tv,Ti<:Integer} =
-    convert(SparseMatrixCSC{Tv,Ti}, SparseMatrixCSC{Tv}(I, size(Z)...))
-
-convert(::Type{AbstractSparseMatrix}, Z::Eye{T}) where {T} = SparseMatrixCSC{T}(I, size(Z)...)
-convert(::Type{AbstractSparseMatrix{Tv}}, Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
-
-convert(::Type{AbstractSparseArray}, Z::Eye{T}) where T = SparseMatrixCSC{T}(I, size(Z)...)
-convert(::Type{AbstractSparseArray{Tv}}, Z::Eye{T}) where {T,Tv} = SparseMatrixCSC{Tv}(I, size(Z)...)
-
-
-convert(::Type{AbstractSparseArray{Tv,Ti}}, Z::Eye{T}) where {T,Tv,Ti} =
-    convert(SparseMatrixCSC{Tv,Ti}, Z)
-convert(::Type{AbstractSparseArray{Tv,Ti,2}}, Z::Eye{T}) where {T,Tv,Ti} =
-    convert(SparseMatrixCSC{Tv,Ti}, Z)
-
-function SparseMatrixCSC{Tv}(R::RectOrDiagonalFill) where {Tv}
-    SparseMatrixCSC{Tv,eltype(axes(R,1))}(R)
-end
-function SparseMatrixCSC{Tv,Ti}(R::RectOrDiagonalFill) where {Tv,Ti}
-    Base.require_one_based_indexing(R)
-    v = parent(R)
-    J = getindex_value(v)*I
-    SparseMatrixCSC{Tv,Ti}(J, size(R))
-end
 
 #########
 # maximum/minimum
@@ -698,35 +652,6 @@ function in(x, A::RectDiagonal{<:Number})
     x == zero(eltype(A)) || x in A.diag
 end
 
-#########
-# mean, std
-#########
-
-mean(A::AbstractFill; dims=(:)) = mean(identity, A; dims=dims)
-function mean(f::Union{Function, Type}, A::AbstractFill; dims=(:))
-    val = float(f(getindex_value(A)))
-    dims isa Colon ? val :
-        Fill(val, ntuple(d -> d in dims ? 1 : size(A,d), ndims(A))...)
-end
-
-
-function var(A::AbstractFill{T}; corrected::Bool=true, mean=nothing, dims=(:)) where {T<:Number}
-    dims isa Colon ? zero(float(T)) :
-        Zeros{float(T)}(ntuple(d -> d in dims ? 1 : size(A,d), ndims(A))...)
-end
-
-cov(A::AbstractFillVector{T}; corrected::Bool=true) where {T<:Number} = zero(float(T))
-cov(A::AbstractFillMatrix{T}; corrected::Bool=true, dims::Integer=1) where {T<:Number} =
-    Zeros{float(T)}(size(A, 3-dims), size(A, 3-dims))
-
-cor(A::AbstractFillVector{T}) where {T<:Number} = one(float(T))
-function cor(A::AbstractFillMatrix{T}; dims::Integer=1) where {T<:Number}
-    out = fill(float(T)(NaN), size(A, 3-dims), size(A, 3-dims))
-    out[LinearAlgebra.diagind(out)] .= 1
-    out
-end
-
-
 #########
 # include
 #########
@@ -735,6 +660,11 @@ include("fillalgebra.jl")
 include("fillbroadcast.jl")
 include("trues.jl")
 
+@static if !isdefined(Base, :get_extension)
+    include("../ext/FillArraysSparseArraysExt.jl")
+    include("../ext/FillArraysStatisticsExt.jl")
+end
+
 ##
 # print
 ##
@@ -781,11 +711,19 @@ function Base.show(io::IO, ::MIME"text/plain", x::Union{Eye, AbstractFill})
 end
 
 function Base.show(io::IO, x::AbstractFill)  # for example (Fill(π,3),)
-    print(io, nameof(typeof(x)), "(")
-    if x isa Union{Zeros, Ones}
+    print(io, nameof(typeof(x)))
+    sz = size(x)
+    args = if x isa Union{Zeros, Ones}
+        T = eltype(x)
+        if T != Float64
+            print(io,"{", T, "}")
+        end
+        print(io, "(")
     else
-        show(io, getindex_value(x))  # show not print to handle (Fill(1f0,2),)
-        ndims(x) > 0 && print(io, ", ")
+        # show, not print, to handle (Fill(1f0,2),)
+        print(io, "(")
+        show(io, getindex_value(x))
+        ndims(x) == 0 || print(io, ", ")
     end
     join(io, size(x), ", ")
     print(io, ")")

src/fillalgebra.jl

@@ -353,6 +353,8 @@ end
 -(a::Zeros) = a
 -(a::AbstractFill) = Fill(-getindex_value(a), size(a))
 
+# special-cased for type-stability, as Ones + Ones is not a Ones
+Base.reduce_first(::typeof(+), x::Ones) = Fill(Base.reduce_first(+, getindex_value(x)), axes(x))
 
 function +(a::Zeros{T}, b::Zeros{V}) where {T, V} # for disambiguity
     promote_shape(a,b)
@@ -467,4 +469,3 @@ function kron(f::AbstractFillVecOrMat, g::AbstractFillVecOrMat)
     sz = _kronsize(f, g)
     _kron(f, g, sz)
 end
-kron(E1::RectDiagonalFill, E2::RectDiagonalFill) = kron(sparse(E1), sparse(E2))

test/runtests.jl

@@ -13,7 +13,11 @@ import FillArrays: AbstractFill, RectDiagonal, SquareEye
 
 using Aqua
 @testset "Project quality" begin
-    Aqua.test_all(FillArrays, ambiguities=false)
+    Aqua.test_all(FillArrays, ambiguities=false,
+        # only test formatting on VERSION >= v1.7
+        # https://github.com/JuliaTesting/Aqua.jl/issues/105#issuecomment-1551405866
+        project_toml_formatting = VERSION >= v"1.7",
+    )
 end
 
 include("infinitearrays.jl")
@@ -307,6 +311,13 @@ end
         @test A[1,:,1] ≡ A[1,1:6,1] ≡ Fill(2.0,6)
         @test A[:,:,:] ≡ A[1:5,1:6,1:7] ≡ A[1:5,:,1:7] ≡ A[:,1:6,1:7] ≡ A
     end
+
+    @testset "StepRangeLen convert" begin
+        for (z,s) in  ((Zeros{Int}(5), StepRangeLen(0, 0, 5)), (Ones{Int}(5), StepRangeLen(1, 0, 5)), (Fill(2,5), StepRangeLen(2, 0, 5)))
+            @test s == z
+            @test StepRangeLen(z) ≡ convert(StepRangeLen, z) ≡ convert(StepRangeLen{Int}, z) ≡ convert(typeof(s), z) ≡ convert(AbstractRange, z) ≡ s
+        end
+    end
 end
 
 @testset "RectDiagonal" begin
@@ -824,6 +835,9 @@ end
     @test diff(Ones{Float64}(10)) ≡ Zeros{Float64}(9)
     @test_throws UndefKeywordError cumsum(Fill(1,1,5))
 
+    @test @inferred(sum([Ones(4)])) ≡ Fill(1.0, 4)
+    @test @inferred(sum([Trues(4)])) ≡ Fill(1, 4)
+
     @testset "infinite arrays" begin
         r = InfiniteArrays.OneToInf()
         A = Ones{Int}((r,))
@@ -1735,7 +1749,11 @@ end
     @test Base.replace_in_print_matrix(Zeros(5,3), 1, 2, "0.0") == " ⋅ "
 
     # 2-arg show, compact printing
+    @test repr(Zeros{Int}()) == "Zeros{$Int}()"
+    @test repr(Zeros{Int}(3)) == "Zeros{$Int}(3)"
     @test repr(Zeros(3)) == "Zeros(3)"
+    @test repr(Ones{Int}(3)) == "Ones{$Int}(3)"
+    @test repr(Ones{Int}(3,2)) == "Ones{$Int}(3, 2)"
     @test repr(Ones(3,2)) == "Ones(3, 2)"
     @test repr(Fill(7,3,2)) == "Fill(7, 3, 2)"
     @test repr(Fill(1f0,10)) == "Fill(1.0f0, 10)"  # Float32!