Stop pirating eigen and svd functions from LinearAlgebra

Project.toml

@@ -1,6 +1,6 @@
 name = "GenericLinearAlgebra"
 uuid = "14197337-ba66-59df-a3e3-ca00e7dcff7a"
-version = "0.3.15"
+version = "1.0.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -10,7 +10,7 @@ libblastrampoline_jll = "8e850b90-86db-534c-a0d3-1478176c7d93"
 
 [compat]
 Quaternions = "0.7.0"
-julia = "1.6"
+julia = "1.10"
 
 [extras]
 DoubleFloats = "497a8b3b-efae-58df-a0af-a86822472b78"

src/GenericLinearAlgebra.jl

@@ -1,6 +1,12 @@
 module GenericLinearAlgebra
 
-import LinearAlgebra: mul!, ldiv!
+using LinearAlgebra: LinearAlgebra,
+    Adjoint, Bidiagonal, Diagonal, Factorization, Givens, HermOrSym, Hermitian, I, LowerTriangular,
+    Rotation, SVD, SymTridiagonal, Symmetric, UnitLowerTriangular, UnitUpperTriangular,
+    UpperTriangular,
+    BLAS,
+    abs2, axpy!, diag, dot, eigencopy_oftype, givens, ishermitian, mul!, rdiv!, tril, triu
+using LinearAlgebra.BLAS: BlasFloat, BlasReal
 
 include("juliaBLAS.jl")
 include("lapack.jl")
@@ -9,6 +15,6 @@ include("householder.jl")
 include("qr.jl")
 include("eigenSelfAdjoint.jl")
 include("eigenGeneral.jl")
-include("tridiag.jl")
 include("svd.jl")
+
 end

src/cholesky.jl

@@ -1,5 +1,3 @@
-using LinearAlgebra: rdiv!
-
 function cholUnblocked!(A::AbstractMatrix{T}, ::Type{Val{:L}}) where {T<:Number}
     n = LinearAlgebra.checksquare(A)
     A[1, 1] = sqrt(A[1, 1])

src/eigenGeneral.jl

@@ -1,9 +1,3 @@
-using Printf
-using LinearAlgebra
-using LinearAlgebra: Givens, Rotation, givens
-
-import Base: \
-
 # Hessenberg Matrix
 struct HessenbergMatrix{T,S<:StridedMatrix} <: AbstractMatrix{T}
     data::S
@@ -25,17 +19,10 @@
         lmul!(G, view(Hd, 1:n, i:n))
         lmul!(G, B)
     end
-    ldiv!(UpperTriangular(Hd), B)
-end
-(\)(H::HessenbergMatrix, B::AbstractVecOrMat) = ldiv!(copy(H), copy(B))
-
-if VERSION < v"1.10"
-    # ensure tests pass on Julia v1.6
-    copy_similar(A::AbstractArray, ::Type{T}) where {T} = copyto!(similar(A, T, size(A)), A)
-    eigtype(T) = promote_type(Float32, typeof(zero(T)/sqrt(abs2(one(T)))))
-    eigencopy_oftype(A, S) = copy_similar(A, S)
-    LinearAlgebra.eigvals(A::HessenbergMatrix{T}; kws...) where T = LinearAlgebra.eigvals!(eigencopy_oftype(A, eigtype(T)); kws...)
+    LinearAlgebra.ldiv!(UpperTriangular(Hd), B)
 end
+LinearAlgebra.:\(H::HessenbergMatrix, B::AbstractVecOrMat) =
+    LinearAlgebra.ldiv!(copy(H), copy(B))
 
 # Hessenberg factorization
 struct HessenbergFactorization{T,S<:StridedMatrix,U} <: Factorization{T}
@@ -46,7 +33,7 @@
 Base.copy(HF::HessenbergFactorization{T,S,U}) where {T,S,U} =
     HessenbergFactorization{T,S,U}(copy(HF.data), copy(HF.τ))
 
-function _hessenberg!(A::StridedMatrix{T}) where {T}
+function hessenberg!(A::StridedMatrix{T}) where {T}
     n = LinearAlgebra.checksquare(A)
     τ = Vector{Householder{T}}(undef, n - 1)
     for i = 1:n-1
@@ -59,7 +46,6 @@
     end
     return HessenbergFactorization{T,typeof(A),eltype(τ)}(A, τ)
 end
-LinearAlgebra.hessenberg!(A::StridedMatrix) = _hessenberg!(A)
 
 Base.size(H::HessenbergFactorization, args...) = size(H.data, args...)
 
@@ -71,6 +57,8 @@
     end
 end
 
+Base.propertynames(F::HessenbergFactorization) = (fieldnames(typeof(F))..., :H)
+
 # Schur
 struct Schur{T,S<:StridedMatrix} <: Factorization{T}
     data::S
@@ -179,10 +167,7 @@
 
     return Schur{T,typeof(HH)}(HH, τ)
 end
-_schur!(A::StridedMatrix; kwargs...) = _schur!(_hessenberg!(A); kwargs...)
-
-# FIXME! Move this method to piracy extension
-LinearAlgebra.schur!(A::StridedMatrix; kwargs...) = _schur!(A; kwargs...)
+schur!(A::StridedMatrix; kwargs...) = _schur!(hessenberg!(A); kwargs...)
 
 function singleShiftQR!(
     HH::StridedMatrix,
@@ -278,11 +263,11 @@
     return HH
 end
 
-_eigvals!(A::StridedMatrix; kwargs...) = _eigvals!(_schur!(A; kwargs...))
+_eigvals!(A::StridedMatrix; kwargs...) = _eigvals!(schur!(A; kwargs...))
 _eigvals!(H::HessenbergMatrix; kwargs...) = _eigvals!(_schur!(H; kwargs...))
 _eigvals!(H::HessenbergFactorization; kwargs...) = _eigvals!(_schur!(H; kwargs...))
 
-function LinearAlgebra.eigvals!(
+function eigvals!(
     A::StridedMatrix;
     sortby::Union{Function,Nothing} = LinearAlgebra.eigsortby,
     kwargs...,
@@ -294,13 +279,13 @@
     LinearAlgebra.sorteig!(_eigvals!(A; kwargs...), sortby)
 end
 
-LinearAlgebra.eigvals!(
+eigvals!(
     H::HessenbergMatrix;
     sortby::Union{Function,Nothing} = LinearAlgebra.eigsortby,
     kwargs...,
 ) = LinearAlgebra.sorteig!(_eigvals!(H; kwargs...), sortby)
 
-LinearAlgebra.eigvals!(
+eigvals!(
     H::HessenbergFactorization;
     sortby::Union{Function,Nothing} = LinearAlgebra.eigsortby,
     kwargs...,
@@ -338,3 +323,17 @@
     end
     return vals
 end
+
+## eigen!
+function eigen!(
+    A::StridedMatrix;
+    sortby::Union{Function,Nothing} = LinearAlgebra.eigsortby,
+    kwargs...,
+)
+
+    if ishermitian(A)
+        return eigen!(Hermitian(A); sortby)
+    end
+
+    throw(ArgumentError("eigen! for general matrices not yet supported. Consider using schur!"))
+end