use multiple dispatch in generic multiplication

Author: dkarrasch

src/LinearMaps.jl

@@ -258,16 +258,16 @@ end
 _unsafe_mul!(y, A::MapOrVecOrMat, x) = mul!(y, A, x)
 _unsafe_mul!(y, A::AbstractVecOrMat, x, α, β) = mul!(y, A, x, α, β)
 _unsafe_mul!(y::AbstractVecOrMat, A::LinearMap, x::AbstractVector, α, β) =
-    _generic_mapvec_mul!(y, A, x, α, β)
+    _generic_map_mul!(y, A, x, α, β)
 _unsafe_mul!(y::AbstractMatrix, A::LinearMap, x::AbstractMatrix) =
-    _generic_mapmat_mul!(y, A, x)
+    _generic_map_mul!(y, A, x)
 _unsafe_mul!(y::AbstractMatrix, A::LinearMap, x::AbstractMatrix, α::Number, β::Number) =
-    _generic_mapmat_mul!(y, A, x, α, β)
-_unsafe_mul!(Y::AbstractMatrix, A::LinearMap, s::Number) = _generic_mapnum_mul!(Y, A, s)
+    _generic_map_mul!(y, A, x, α, β)
+_unsafe_mul!(Y::AbstractMatrix, A::LinearMap, s::Number) = _generic_map_mul!(Y, A, s)
 _unsafe_mul!(Y::AbstractMatrix, A::LinearMap, s::Number, α::Number, β::Number) =
-    _generic_mapnum_mul!(Y, A, s, α, β)
+    _generic_map_mul!(Y, A, s, α, β)
 
-function _generic_mapvec_mul!(y, A, x, α, β)
+function _generic_map_mul!(y, A, x::AbstractVector, α, β)
     # this function needs to call mul! for, e.g.,  AdjointMap{...,<:CustomMap}
     if isone(α)
         iszero(β) && return mul!(y, A, x)
@@ -294,21 +294,19 @@ function _generic_mapvec_mul!(y, A, x, α, β)
         return y
     end
 end
-
-function _generic_mapmat_mul!(Y, A, X)
+function _generic_map_mul!(Y, A, X::AbstractMatrix)
     for (Xi, Yi) in zip(eachcol(X), eachcol(Y))
         mul!(Yi, A, Xi)
     end
     return Y
 end
-function _generic_mapmat_mul!(Y, A, X, α, β)
+function _generic_map_mul!(Y, A, X::AbstractMatrix, α, β)
     for (Xi, Yi) in zip(eachcol(X), eachcol(Y))
         mul!(Yi, A, Xi, α, β)
     end
     return Y
 end
-
-function _generic_mapnum_mul!(Y, A, s)
+function _generic_map_mul!(Y, A, s::Number)
     T = promote_type(eltype(A), typeof(s))
     ax2 = axes(A)[2]
     xi = zeros(T, ax2)
@@ -319,7 +317,7 @@ function _generic_mapnum_mul!(Y, A, s)
     end
     return Y
 end
-function _generic_mapnum_mul!(Y, A, s, α, β)
+function _generic_map_mul!(Y, A, s::Number, α, β)
     T = promote_type(eltype(A), typeof(s))
     ax2 = axes(A)[2]
     xi = zeros(T, ax2)

src/transpose.jl

@@ -50,44 +50,24 @@ Base.:(==)(A::LinearMap, B::TransposeMap)    = issymmetric(A) && B.lmap == A
 Base.:(==)(A::LinearMap, B::AdjointMap)      = ishermitian(A) && B.lmap == A
 
 # multiplication with vector/matrices
-# # TransposeMap
-_unsafe_mul!(y::AbstractVecOrMat, A::TransposeMap, x::AbstractVector) =
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : error("transpose not implemented for $(A.lmap)")
-_unsafe_mul!(y::AbstractMatrix, A::TransposeMap, x::AbstractMatrix) =
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : _generic_mapmat_mul!(y, A, x)
-_unsafe_mul!(y::AbstractMatrix, A::TransposeMap, x::Number) =
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : _generic_mapnum_mul!(y, A, x)
-_unsafe_mul!(y::AbstractVecOrMat, A::TransposeMap, x::AbstractVector, α::Number, β::Number)=
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapvec_mul!(y, A, x, α, β)
-_unsafe_mul!(y::AbstractMatrix, A::TransposeMap, x::AbstractMatrix, α::Number, β::Number) =
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapmat_mul!(y, A, x, α, β)
-_unsafe_mul!(y::AbstractMatrix, A::TransposeMap, x::Number, α::Number, β::Number) =
-    issymmetric(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapnum_mul!(y, A, x, α, β)
-# # AdjointMap
-_unsafe_mul!(y::AbstractVecOrMat, A::AdjointMap, x::AbstractVector) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : error("adjoint not implemented for $(A.lmap)")
-_unsafe_mul!(y::AbstractMatrix, A::AdjointMap, x::AbstractMatrix) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : _generic_mapmat_mul!(y, A, x)
-_unsafe_mul!(y::AbstractMatrix, A::AdjointMap, x::Number) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x) : _generic_mapnum_mul!(y, A, x)
-_unsafe_mul!(y::AbstractVecOrMat, A::AdjointMap, x::AbstractVector, α::Number, β::Number) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapvec_mul!(y, A, x, α, β)
-_unsafe_mul!(y::AbstractMatrix, A::AdjointMap, x::AbstractMatrix, α::Number, β::Number) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapmat_mul!(y, A, x, α, β)
-_unsafe_mul!(y::AbstractMatrix, A::AdjointMap, x::Number, α::Number, β::Number) =
-    ishermitian(A.lmap) ?
-        _unsafe_mul!(y, A.lmap, x, α, β) : _generic_mapnum_mul!(y, A, x, α, β)
+for (Typ, prop, text) in ((AdjointMap, ishermitian, "adjoint"), (TransposeMap, issymmetric, "transpose"))
+    @eval _unsafe_mul!(y::AbstractVecOrMat, A::$Typ, x::AbstractVector) =
+        $prop(A.lmap) ?
+            _unsafe_mul!(y, A.lmap, x) : error($text * " not implemented for $(A.lmap)")
+    @eval _unsafe_mul!(y::AbstractVecOrMat, A::$Typ, x::AbstractVector, α::Number, β::Number) =
+        $prop(A.lmap) ?
+            _unsafe_mul!(y, A.lmap, x, α, β) : _generic_map_mul!(y, A, x, α, β)
+
+    for In in (Number, AbstractMatrix)
+        @eval _unsafe_mul!(y::AbstractMatrix, A::$Typ, x::$In) =
+            $prop(A.lmap) ?
+                _unsafe_mul!(y, A.lmap, x) : _generic_map_mul!(y, A, x)
+
+        @eval _unsafe_mul!(y::AbstractMatrix, A::$Typ, x::$In, α::Number, β::Number) =
+            ishermitian(A.lmap) ?
+                _unsafe_mul!(y, A.lmap, x, α, β) : _generic_map_mul!(y, A, x, α, β)
+    end
+end
 
 # # ConjugateMap
 const ConjugateMap = AdjointMap{<:Any, <:TransposeMap}
@@ -104,9 +84,12 @@ for (In, Out) in ((AbstractVector, AbstractVecOrMat), (AbstractMatrix, AbstractM
         end
     end
 end
+function _unsafe_mul!(y::AbstractMatrix, Ac::ConjugateMap, x::Number)
+    return _conjmul!(y, Ac.lmap.lmap, x)
+end
 
 # multiplication helper function
-_conjmul!(y, A, x) = conj!(mul!(y, A, conj(x)))
+_conjmul!(y, A, x) = conj!(_unsafe_mul!(y, A, conj(x)))
 function _conjmul!(y, A, x::AbstractVector, α, β)
     xca = conj!(x * α)
     z = A * xca

test/linearmaps.jl

@@ -63,9 +63,9 @@ end
     w = rand(ComplexF64, 10); W = rand(ComplexF64, 10, 3)
     F(v) == F*v
     @test mul!(w, F, v) === w == F * v
-    @test_throws ErrorException F' * v
+    @test_throws ErrorException("transpose not implemented for "*sprint((t, s) -> show(t, "text/plain", s), F)) F' * v
     @test_throws ErrorException transpose(F) * v
-    @test_throws ErrorException mul!(w, adjoint(FC), v)
+    @test_throws ErrorException("adjoint not implemented for "*sprint((t, s) -> show(t, "text/plain", s), FC)) mul!(w, adjoint(FC), v)
     @test_throws ErrorException mul!(w, transpose(F), v)
     FM = convert(AbstractMatrix, F)
     L = LowerTriangular(ones(10, 10))