improve coverage

Author: dkarrasch

src/LinearMaps.jl

@@ -284,7 +284,7 @@ LinearMap(f, M::Int; kwargs...) = LinearMap{Float64}(f, M; kwargs...)
 LinearMap(f, M::Int, N::Int; kwargs...) = LinearMap{Float64}(f, M, N; kwargs...)
 LinearMap(f, fc, M::Int; kwargs...) = LinearMap{Float64}(f, fc, M; kwargs...)
 LinearMap(f, fc, M::Int, N::Int; kwargs...) = LinearMap{Float64}(f, fc, M, N; kwargs...)
-LinearMap(λ::Number, M::Int, N::Int) = LinearMap(λ, (M, N))
+LinearMap(λ::Number, M::Int, N::Int) = FillMap(λ, (M, N))
 LinearMap(λ::Number, dims::Dims{2}) = FillMap(λ, dims)
 
 LinearMap{T}(A::MapOrMatrix; kwargs...) where {T} = WrappedMap{T}(A; kwargs...)

test/fillmap.jl

@@ -2,29 +2,38 @@ using LinearMaps, LinearAlgebra, Test
 
 @testset "filled maps" begin
     M, N = 2, 3
-    α = rand()
-    β = rand()
     μ = rand()
     for λ in (true, false, 3, μ, μ + 2im)
         L = LinearMap(λ, (M, N))
+        @test L == LinearMap(λ, M, N)
+        @test LinearMaps.MulStyle(L) === LinearMaps.FiveArg()
         A = fill(λ, (M, N))
         x = rand(typeof(λ) <: Real ? Float64 : ComplexF64, 3)
-        X = rand(typeof(λ) <: Real ? Float64 : ComplexF64, 3, 3)
+        X = rand(typeof(λ) <: Real ? Float64 : ComplexF64, 3, 4)
         w = similar(x, 2)
-        W = similar(X, 2, 3)
+        W = similar(X, 2, 4)
         @test size(L) == (M, N)
         @test adjoint(L) == LinearMap(adjoint(λ), (3,2))
         @test transpose(L) == LinearMap(λ, (3,2))
         @test Matrix(L) == A
         @test L * x ≈ A * x
         @test mul!(w, L, x) ≈ A * x
         @test mul!(W, L, X) ≈ A * X
-        @test mul!(copy(w), L, x, α, β) ≈ A * x * α + w * β
-        @test mul!(copy(W), L, X, α, β) ≈ A * X * α + W * β
+        for α in (true, false, 1, 0, randn()), β in (true, false, 1, 0, randn())
+            @test mul!(copy(w), L, x, α, β) ≈ fill(λ * sum(x) * α, M) + w * β
+            @test mul!(copy(W), L, X, α, β) ≈ λ * reduce(vcat, sum(X, dims=1) for _ in 1:2) * α + W * β
+        end
     end
-    @test issymmetric(LinearMap(μ + 0im, (3, 3)))
+    @test issymmetric(LinearMap(μ + 1im, (3, 3)))
+    @test ishermitian(LinearMap(μ + 0im, (3, 3)))
+    @test isposdef(LinearMap(μ, (1,1))) == isposdef(μ)
+    @test !isposdef(LinearMap(μ, (3,3)))
+    α = rand()
+    β = rand()
     @test LinearMap(μ, (M, N)) + LinearMap(α, (M, N)) == LinearMap(μ + α, (M, N))
     @test LinearMap(μ, (M, N)) - LinearMap(α, (M, N)) == LinearMap(μ - α, (M, N))
     @test α*LinearMap(μ, (M, N)) == LinearMap(α * μ, (M, N))
     @test LinearMap(μ, (M, N))*α == LinearMap(μ * α, (M, N))
+    @test LinearMap(μ, (M, N))*LinearMap(μ, (N, M)) == LinearMap(μ^2*N, (M, M))
+    @test Matrix(LinearMap(μ, (M, N))*LinearMap(μ, (N, M))) == fill(μ, (M, N))*fill(μ, (N, M))
 end

test/numbertypes.jl

@@ -45,6 +45,7 @@ using Test, LinearMaps, LinearAlgebra, Quaternions
     @test M == (L * L * γ) * β == (L * L * α) * β == (L * L * α) * β.λ
     @test length(M.maps) == 3
     @test M.maps[1].λ == γ*β.λ
+    @test γ*LinearMap(γ, (3, 4)) == LinearMap(γ^2, (3, 4)) == LinearMap(γ, (3, 4))*γ
 
     # exercise non-RealOrComplex scalar operations
     @test Array(γ * (L'*L)) ≈ γ * (A'*A) # CompositeMap