remove mapreduce for generic f, add Statistics.mean

Author: dkarrasch

Project.toml

@@ -5,6 +5,7 @@ version = "3.6.0"
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
 julia = "1.6"

src/LinearMaps.jl

@@ -8,6 +8,8 @@ using LinearAlgebra
 import LinearAlgebra: mul!
 using SparseArrays
 
+import Statistics: mean
+
 using Base: require_one_based_indexing
 
 abstract type LinearMap{T} end
@@ -22,6 +24,15 @@ const LinearMapTupleOrVector = Union{LinearMapTuple,LinearMapVector}
 
 Base.eltype(::LinearMap{T}) where {T} = T
 
+# conversion to LinearMap
+Base.convert(::Type{LinearMap}, A::LinearMap) = A
+Base.convert(::Type{LinearMap}, A::AbstractVecOrMat) = LinearMap(A)
+
+convert_to_lmaps() = ()
+convert_to_lmaps(A) = (convert(LinearMap, A),)
+@inline convert_to_lmaps(A, B, Cs...) =
+    (convert(LinearMap, A), convert(LinearMap, B), convert_to_lmaps(Cs...)...)
+
 abstract type MulStyle end
 
 struct FiveArg <: MulStyle end
@@ -65,14 +76,6 @@ function check_dim_mul(C, A, B)
     return nothing
 end
 
-# conversion of AbstractVecOrMat to LinearMap
-convert_to_lmaps_(A::AbstractVecOrMat) = LinearMap(A)
-convert_to_lmaps_(A::LinearMap) = A
-convert_to_lmaps() = ()
-convert_to_lmaps(A) = (convert_to_lmaps_(A),)
-@inline convert_to_lmaps(A, B, Cs...) =
-    (convert_to_lmaps_(A), convert_to_lmaps_(B), convert_to_lmaps(Cs...)...)
-
 _front(As::Tuple) = Base.front(As)
 _front(As::AbstractVector) = @inbounds @views As[1:end-1]
 _tail(As::Tuple) = Base.tail(As)

src/kronecker.jl

@@ -97,7 +97,7 @@ Construct a lazy representation of the `k`-th Kronecker power
 ⊗(A, B, Cs...) = kron(convert_to_lmaps(A, B, Cs...)...)
 
 Base.:(^)(A::MapOrMatrix, ::KronPower{p}) where {p} =
-    kron(ntuple(n -> convert_to_lmaps_(A), Val(p))...)
+    kron(ntuple(n -> convert(LinearMap, A), Val(p))...)
 
 Base.size(A::KroneckerMap) = map(*, size.(A.maps)...)
 
@@ -287,7 +287,7 @@ where `A` can be a square `AbstractMatrix` or a `LinearMap`.
 ⊕(a, b, c...) = kronsum(a, b, c...)
 
 Base.:(^)(A::MapOrMatrix, ::KronSumPower{p}) where {p} =
-    kronsum(ntuple(n->convert_to_lmaps_(A), Val(p))...)
+    kronsum(ntuple(n -> convert(LinearMap, A), Val(p))...)
 
 Base.size(A::KroneckerSumMap, i) = prod(size.(A.maps, i))
 Base.size(A::KroneckerSumMap) = (size(A, 1), size(A, 2))

src/linearcombination.jl

@@ -20,12 +20,9 @@ Base.mapreduce(::typeof(identity), ::typeof(Base.add_sum), maps::LinearMapTupleO
 # this method is required for type stability in the mixed-map-equal-eltype case
 Base.mapreduce(::typeof(identity), ::typeof(Base.add_sum), maps::AbstractVector{<:LinearMap{T}}) where {T} =
     LinearCombination{T}(maps)
-# the following two methods are needed to make e.g. `mean` work,
-# for which `f` is some sort of promotion function
-Base.mapreduce(f::F, ::typeof(Base.add_sum), maps::LinearMapTupleOrVector) where {F} =
-    LinearCombination{promote_type(map(eltype, maps)...)}(f.(maps))
-Base.mapreduce(f::F, ::typeof(Base.add_sum), maps::AbstractVector{<:LinearMap{T}}) where {F,T} =
-    LinearCombination{T}(f.(maps))
+
+mean(f::F, maps::LinearMapTupleOrVector) where {F} = sum(f, maps) / length(maps)
+mean(maps::LinearMapTupleOrVector) = sum(maps) / length(maps)
 
 MulStyle(A::LinearCombination) = MulStyle(A.maps...)
 

test/linearcombination.jl

@@ -16,14 +16,19 @@ using LinearMaps: FiveArg, LinearMapTuple, LinearMapVector
     @test (@inferred sum(Lv.maps::LinearMapVector)) == Lv
     @test isa((@inferred mean(Lv.maps)),
         LinearMaps.ScaledMap{ComplexF64,Float64,<:LinearMaps.LinearCombination{ComplexF64,<:LinearMapVector}})
-    @test (@inferred mean(x -> x*x, Lv.maps)) == (@inferred sum(x -> x*x, Lv.maps)/n)
+    @test (@inferred mean(L.maps)) == (@inferred mean(Lv.maps)) == (@inferred sum(Lv.maps))/n
+    @test (@inferred mean(x -> x*x, L.maps)) == (@inferred sum(x -> x*x, L.maps))/n
+    @test mean(x -> x*x, Lv.maps) == (sum(x -> x*x, Lv.maps))/n
     @test L == Lv
-    @test isa((@inferred sum([CS!, LinearMap(randn(eltype(CS!), size(CS!)))])),
-        LinearMaps.LinearCombination{<:ComplexF64,<:LinearMapVector})
-    A = randn(eltype(CS!), size(CS!))
-    @test (@inferred mean([CS!, LinearMap(A)])) == (@inferred sum([CS!, LinearMap(A)])/2)
-    @test isa(sum([CS!, LinearMap(real(A))]),
+    A = LinearMap(randn(eltype(CS!), size(CS!)))
+    Ar = LinearMap(real(A.lmap))
+    @test isa((@inferred sum([CS!, A])),
         LinearMaps.LinearCombination{<:ComplexF64,<:LinearMapVector})
+    @test (@inferred mean([CS!, A])) == (@inferred sum([CS!, A]))/2
+    @test (@inferred mean([CS!, A])) == (@inferred mean(identity, [CS!, A])) == (@inferred sum([CS!, A]))/2
+    @test isa(sum([CS!, Ar]), LinearMaps.LinearCombination{<:ComplexF64,<:LinearMapVector})
+    @test sum([CS!, Ar])/2 == mean([CS!, Ar])
+    @test sum([CS!, Ar]) == sum(identity, [CS!, Ar])
     for sum1 in (CS!, L, Lv), sum2 in (CS!, L, Lv)
         m1 = sum1 == CS! ? 1 : 10
         m2 = sum2 == CS! ? 1 : 10