Support passing `Hermitian` matrix to `eigh_x`

[mtfishman]

For example:

julia> using MatrixAlgebraKit, LinearAlgebra

julia> eigh_full(Hermitian(randn(4, 4)))
ERROR: MethodError: no method matching default_eigh_algorithm(::Type{Hermitian{Float64, Matrix{Float64}}})
This error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.

Closest candidates are:
  default_eigh_algorithm(::Type; kwargs...)
   @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:90
  default_eigh_algorithm(::Any; kwargs...)
   @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:89
  default_eigh_algorithm(::Type{T}; kwargs...) where T<:(StridedMatrix{T} where T<:Union{Float32, Float64, ComplexF64, ComplexF32})
   @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:93

Stacktrace:
  [1] default_eigh_algorithm(T::Type; kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:91
  [2] default_eigh_algorithm(T::Type)
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:90
  [3] default_algorithm(::typeof(eigh_full!), ::Type{Hermitian{Float64, Matrix{Float64}}}; kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:99
  [4] default_algorithm(::typeof(eigh_full!), ::Type{Hermitian{Float64, Matrix{Float64}}})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/interface/eigh.jl:98
  [5] default_algorithm(f::typeof(eigh_full!), A::Hermitian{Float64, Matrix{Float64}}; kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:108
  [6] default_algorithm(f::typeof(eigh_full!), A::Hermitian{Float64, Matrix{Float64}})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:108
  [7] select_algorithm(f::typeof(eigh_full!), A::Hermitian{Float64, Matrix{Float64}}, alg::Nothing; kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:81
  [8] select_algorithm(f::typeof(eigh_full!), A::Hermitian{Float64, Matrix{Float64}}, alg::Nothing)
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:79
  [9] eigh_full!(A::Hermitian{Float64, Matrix{Float64}}; alg::Nothing, kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:183
 [10] eigh_full!(A::Hermitian{Float64, Matrix{Float64}})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:182
 [11] eigh_full(A::Hermitian{Float64, Matrix{Float64}}; kwargs::@Kwargs{})
    @ MatrixAlgebraKit ~/.julia/packages/MatrixAlgebraKit/0wHx6/src/algorithms.jl:178
 [12] top-level scope
    @ REPL[2]:1
 [13] top-level scope
    @ none:1

(test) pkg> st MatrixAlgebraKit
Status `~/.julia/dev/MatrixAlgebraKit/test/Project.toml`
  [6c742aac] MatrixAlgebraKit v0.2.2

I think this would be nice to support for convenience. For example, a convenient way to make a Hermitian matrix is LinearAlgebra.hermitianpart, but that outputs the matrix wrapped in Hermitian (obviously you can then unwrap it but honestly there isn't a great generic interface for that, for example one that support GPU arrays). (EDIT: I was being dense, one way to do it would be eigh_full(parent(hermitianpart(A))), but still that is a bit annoying.)

[mtfishman]

I'll try to anticipate some pushback on this (and I have a strong suspicion this was a deliberate design choice): one then might wonder if we need to support Hermitian in other functions in MatrixAlgebraKit, along with other LinearAlgebra wrappers. That could definitely start to get annoying. Maybe one could argue that eigh_x is a special case. I don't have a great answer for that.

[lkdvos]

I think it was a deliberate design choice to use functions instead of wrapper types to implement hermitian or non-hermitian eigensolvers, I'm not sure if there is such a strong opinion on supporting the type itself.

Implementation-wise, it seems somewhat straightforward to just unwrap everything and pass it on to the parent, I'm fine with supporting this

[Jutho]

As expressed somewhere before, I don't like the wrapper types of LinearAlgebra as I don't think they are really composable. Not that I would object strongly to supporting this specific behavior, but given the motivation, what I would rather like as a solution is to have a hermitianpart(!) implementation (not necessarily the same name) in MatrixAlgebraKit.jl. Preferably, this would be an implementation that just immediately works for CuArray instances as well (although overloading in the extension is also fine).

The LinearAlgebra.jl implementation is written using elementswise indexing and would thus fail for CuArray instances, like so many methods from the standard library. I don't see a custom definition for hermitianpart! in CUDA.jl yet.