Adding (SymTri)Diagonal, Symmetric or Hermitian matrices together

[jebej]

Currently adding e.g. two Symmetric matrices together results in a regular array. It would seem appropriate to add special methods:

- S + S = S
- S + D = S
- S + STD = S
- H + H = H
- H + D{Real} = H
- H + S{Real} = H
- H + STD{Real} = S

I hope I haven't made any mistakes with the above...

If that proposal is accepted, would the following style of definition be ok?

+(A::Symmetric,B::Symmetric) = Symmetric(A+B)

[kshyatt]

If you'd like to open a PR to do this, sounds reasonable to me. If you're unsure of what the resultant types should be or the rationale, you can add "RFC" to the title (request for comment). @andreasnoack, @Sacha0, or @fredrikekre could probably give you some guidance if you'd like.

[fredrikekre]

+1, this is on my Symmetric/Hermitian TODO list.

I think we can do better than +(A::Symmetric,B::Symmetric) = Symmetric(A+B) though, something like +(A::Symmetric,B::Symmetric) = Symmetric(A.data+B.data) is much faster, just need to be clever about the uplo char

julia> foo(A, B) = Symmetric(A + B);

julia> bar(A, B) = Symmetric(A.data + B.data);

julia> N = 100; A = rand(N, N); S = Symmetric(A);

julia> @btime foo($S, $S);
  51.371 μs (3 allocations: 78.23 KiB)

julia> @btime bar($S, $S);
  5.989 μs (3 allocations: 78.23 KiB)

julia> N = 1000; A = rand(N, N); S = Symmetric(A);

julia> @btime foo($S, $S);
  4.455 ms (3 allocations: 7.63 MiB)

julia> @btime bar($S, $S);
  1.009 ms (3 allocations: 7.63 MiB)

Will you submit a PR?

[jebej]

Yeah, the uplo is the issue. If they are not the same, then adding the data will not work.

[fredrikekre]

function +(A::Symmetric, B::Symmetric)
    if A.uplo == 'U'
        if B.uplo == 'U'
            return Symmetric(A.data + B.data, :U)
        else # B.uplo == 'L'
            return Symmetric(A.data + B.data.', :U)
        end
    else # A.uplo == 'L'
        if B.uplo == 'L'
            return Symmetric(A.data + B.data, :L)
        else # B.uplo == 'U'
            return Symmetric(A.data + B.data.', :L)
        end
    end
end

But then we have to think about JuliaLang/julia#22396 (comment) I think, e.g. if the Symmetric/Hermitian wrappers should be recursive like the closely linked [c]transpose operators.

[jebej]

The transpose in the last case should still be on B.

[fredrikekre]

Yea, updated.

[jebej]

I personally do not have too much use for block matrices, but the transpose would need to be recursive in that case. I believe the plan (#20978) was to add a recursive transpose method and have the .' operator be non-recursive.

[fredrikekre]

For a start we can limit this to Symmetric{<:Number} and Hermitian{<:Number} as in JuliaLang/julia#22396

[theogf]

Is is this feature still considered? that would be awesome to get it implemented!

[StefanKarpinski]

Yes, this seems like it can be considered a minor change.

[dkarrasch]

This was first fixed in JuliaLang/julia#29500 (v1.2), and most recently touched in JuliaLang/julia#35325 (v1.5).