Give Adjoint/Transpose ConjRowVector/RowVector's map/broadcast behavi…

…ors and test.

base/linalg/adjtrans.jl

@@ -110,6 +110,35 @@ typed_hcat(::Type{T}, avs::Union{Number,AdjointAbsVec}...) where {T} = Adjoint(t
 typed_hcat(::Type{T}, avs::Union{Number,TransposeAbsVec}...) where {T} = Transpose(typed_vcat(T, map(Transpose, avs)...))
 
 
+### higher order functions
+# preserve Adjoint/Transpose wrapper around vectors
+# to retain the associated semantics post-map/broadcast
+
+# vectorfy takes an Adoint/Transpose-wrapped vector and builds
+# an unwrapped vector with the entrywise-same contents
+vectorfy(x::Number) = x
+vectorfy(adjvec::AdjointAbsVec) = map(Adjoint, adjvec.parent)
+vectorfy(transvec::TransposeAbsVec) = map(Transpose, transvec.parent)
+vectorfyall(transformedvecs...) = (map(vectorfy, transformedvecs)...,)
+
+# map over collections of Adjoint/Transpose-wrapped vectors
+# note that the caller's operation `f` should be applied to the entries of the wrapped
+# vectors, rather than the entires of the wrapped vector's parents. so first we use vectorfy
+# to build unwrapped vectors with entrywise-same contents as the wrapped input vectors.
+# then we map the caller's operation over that set of unwrapped vectors. but now re-wrapping
+# the resulting vector would inappropriately transform the result vector's entries. so
+# instead of simply mapping the caller's operation over the set of unwrapped vectors,
+# we map Adjoint/Transpose composed with the caller's operationt over the set of unwrapped
+# vectors. then re-wrapping the result vector yields a wrapped vector with the correct entries.
+map(f, avs::AdjointAbsVec...) = Adjoint(map(Adjoint∘f, vectorfyall(avs...)...))
+map(f, tvs::TransposeAbsVec...) = Transpose(map(Transpose∘f, vectorfyall(tvs...)...))
+
+# broadcast over collections of Adjoint/Transpose-wrapped vectors and numbers
+# similar explanation for these definitions as for map above
+broadcast(f, avs::Union{Number,AdjointAbsVec}...) = Adjoint(broadcast(Adjoint∘f, vectorfyall(avs...)...))
+broadcast(f, tvs::Union{Number,TransposeAbsVec}...) = Transpose(broadcast(Transpose∘f, vectorfyall(tvs...) ...))
+
+
 ### linear algebra
 
 # definitions necessary for test/linalg/rowvector.jl to pass

test/linalg/adjtrans.jl

@@ -303,3 +303,39 @@ end
     @test hcat(Adjoint(vecvec), Adjoint(vecvec))::Adjoint{Adjoint{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == hcat(avecvec, avecvec)
     @test hcat(Transpose(vecvec), Transpose(vecvec))::Transpose{Transpose{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == hcat(tvecvec, tvecvec)
 end
+
+@testset "map/broadcast over Adjoint/Transpose-wrapped vectors and Numbers" begin
+    # map and broadcast over Adjoint/Transpose-wrapped vectors and Numbers
+    # should preserve the Adjoint/Transpose-wrapper to preserve semantics downstream
+    vec, tvec, avec = [1im, 2im], [1im 2im], [-1im -2im]
+    vecvec = [[1im, 2im], [3im, 4im]]
+    tvecvec = [[[1im 2im]] [[3im 4im]]]
+    avecvec = [[[-1im -2im]] [[-3im -4im]]]
+    # unary map over wrapped vectors with concrete scalar eltype
+    @test map(-, Adjoint(vec))::Adjoint{Complex{Int},Vector{Complex{Int}}} == -avec
+    @test map(-, Transpose(vec))::Transpose{Complex{Int},Vector{Complex{Int}}} == -tvec
+    # unary map over wrapped vectors with concrete array eltype
+    @test map(-, Adjoint(vecvec))::Adjoint{Adjoint{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == -avecvec
+    @test map(-, Transpose(vecvec))::Transpose{Transpose{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == -tvecvec
+    # binary map over wrapped vectors with concrete scalar eltype
+    @test map(+, Adjoint(vec), Adjoint(vec))::Adjoint{Complex{Int},Vector{Complex{Int}}} == avec + avec
+    @test map(+, Transpose(vec), Transpose(vec))::Transpose{Complex{Int},Vector{Complex{Int}}} == tvec + tvec
+    # binary map over wrapped vectors with concrete array eltype
+    @test map(+, Adjoint(vecvec), Adjoint(vecvec))::Adjoint{Adjoint{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == avecvec + avecvec
+    @test map(+, Transpose(vecvec), Transpose(vecvec))::Transpose{Transpose{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == tvecvec + tvecvec
+    # unary broadcast over wrapped vectors with concrete scalar eltype
+    @test broadcast(-, Adjoint(vec))::Adjoint{Complex{Int},Vector{Complex{Int}}} == -avec
+    @test broadcast(-, Transpose(vec))::Transpose{Complex{Int},Vector{Complex{Int}}} == -tvec
+    # unary broadcast over wrapped vectors with concrete array eltype
+    @test broadcast(-, Adjoint(vecvec))::Adjoint{Adjoint{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == -avecvec
+    @test broadcast(-, Transpose(vecvec))::Transpose{Transpose{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == -tvecvec
+    # binary broadcast over wrapped vectors with concrete scalar eltype
+    @test broadcast(+, Adjoint(vec), Adjoint(vec))::Adjoint{Complex{Int},Vector{Complex{Int}}} == avec + avec
+    @test broadcast(+, Transpose(vec), Transpose(vec))::Transpose{Complex{Int},Vector{Complex{Int}}} == tvec + tvec
+    # binary broadcast over wrapped vectors with concrete array eltype
+    @test broadcast(+, Adjoint(vecvec), Adjoint(vecvec))::Adjoint{Adjoint{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == avecvec + avecvec
+    @test broadcast(+, Transpose(vecvec), Transpose(vecvec))::Transpose{Transpose{Complex{Int},Vector{Complex{Int}}},Vector{Vector{Complex{Int}}}} == tvecvec + tvecvec
+    # trinary broadcast over wrapped vectors with concrete scalar eltype and numbers
+    @test broadcast(+, Adjoint(vec), 1, Adjoint(vec))::Adjoint{Complex{Int},Vector{Complex{Int}}} == avec + avec .+ 1
+    @test broadcast(+, Transpose(vec), 1, Transpose(vec))::Transpose{Complex{Int},Vector{Complex{Int}}} == tvec + tvec .+ 1
+end