Extend convert_eltype to LinearAgebra.Factorization

Author: emmt

NEWS.md

@@ -8,6 +8,8 @@ This page describes the most important changes in `TypeUtils`. The format is bas
 
 ### Added
 
+- Extend `convert_eltype(T,A)` for `A <: LinearAgebra.Factorization`.
+
 - Tests with [`Aqua.jl`](https://github.com/JuliaTesting/Aqua.jl).
 
 ### Fixed

Project.toml

@@ -4,10 +4,12 @@ authors = ["Éric Thiébaut <[email protected]> and contributors"]
 version = "1.7.1"
 
 [deps]
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 
 [compat]
 Aqua = "0.8"
+LinearAlgebra = "<0.0.1, 1"
 OffsetArrays = "1"
 Requires = "1"
 Test = "<0.0.1, 1"

src/TypeUtils.jl

@@ -38,19 +38,19 @@ export
     to_same_concrete_type,
     unitless
 
-using Base: OneTo
-
-if !isdefined(Base, :get_extension)
-    using Requires
-end
-
 include("macros.jl")
 
 @public BareNumber
 @public Converter
 @public Dim
 @public Unsupported
 
+using Base: OneTo
+using LinearAlgebra
+if !isdefined(Base, :get_extension)
+    using Requires
+end
+
 include("types.jl")
 include("methods.jl")
 include("numbers.jl")

src/arrays.jl

@@ -157,11 +157,38 @@ convert_eltype(::Type{T}, x::X) where {T,X} = as(convert_eltype(T, X), x)
 convert_eltype(::Type{T}, ::Type{X}) where {T,X} =
     error("don't know how to convert the element type of type `$X` to `$T`")
 
+# As of Julia 1.11 `AbstractMatrix{T}(A)` or `AbstractArray{T}(A)` can be used to convert
+# element type of `A` for Adjoint, Bidiagonal, Diagonal, Hermitian,
+# LinearAlgebra.LQPackedQ, LowerTriangular, SymTridiagonal, Symmetric, Transpose,
+# Tridiagonal, UnitLowerTriangular, UnitUpperTriangular, UpperHessenberg, UpperTriangular,
+# etc.
 convert_eltype(::Type{T}, A::AbstractArray{T}) where {T} = A
-convert_eltype(::Type{T}, A::AbstractArray) where {T} = as(AbstractArray{T}, A)
+convert_eltype(::Type{T}, A::AbstractArray) where {T} = AbstractArray{T}(A)
 convert_eltype(::Type{T}, ::Type{<:Array{<:Any,N}}) where {T,N} = Array{T,N}
 convert_eltype(::Type{T}, ::Type{<:AbstractArray{<:Any,N}}) where {T,N} = AbstractArray{T,N}
 
+# `LinearAlgebra.Factorization{T}(A)` can be used to convert element type of `A` for QR,
+# LinearAlgebra.QRCompactWY, QRPivoted, LQ, Cholesky, CholeskyPivoted, LU, LDLt,
+# BunchKaufman, SVD, etc.
+convert_eltype(::Type{T}, A::Factorization{T}) where {T} = A
+convert_eltype(::Type{T}, A::Factorization) where {T} = Factorization{T}(A)
+if VERSION < v"1.7.0-beta1"
+    # For old Julia versions, the above is not sufficient for SVD.
+    convert_eltype(::Type{T}, A::SVD{T}) where {T} = A
+    convert_eltype(::Type{T}, A::SVD) where {T} =
+        SVD(convert(AbstractMatrix{T}, A.U),
+            convert(AbstractVector{real(T)}, A.S),
+            convert(AbstractMatrix{T}, A.Vt))
+end
+
+# For `Adjoint` and `Transpose`, we want to preserve this structure.
+for S in (:Adjoint, :Transpose)
+    @eval begin
+        convert_eltype(::Type{T}, A::$S{T}) where {T} = A
+        convert_eltype(::Type{T}, A::$S) where {T} = $S(convert_eltype(T, parent(A)))
+    end
+end
+
 # Convert element type for numbers.
 convert_eltype(::Type{T}, ::Type{<:Number}) where {T} = T
 

test/runtests.jl

@@ -1,4 +1,5 @@
 module TestingTypeUtilsWithoutExtensions
+
 using TypeUtils
 using Test
 
@@ -16,6 +17,7 @@ module TestingTypeUtils
 
 using TypeUtils
 using TypeUtils: BareNumber, BIT_INTEGERS, Unsupported
+using LinearAlgebra
 using Unitful
 using OffsetArrays
 using Test
@@ -732,6 +734,133 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
 
     end
 
+    @testset "LinearAlgebra" begin
+        A = ComplexF32.([9+1im 2-3im 1; 0 7 1; 0 0 4])
+        AAt = A*A'
+        T = ComplexF64 # a wider type than eltype(A) for exact conversion
+
+        B = transpose(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Transpose{T}
+        @test C == B
+
+        B = adjoint(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Adjoint{T}
+        @test C == B
+
+        B = Diagonal(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Diagonal{T}
+        @test C == B
+
+        B = Bidiagonal(A, :U)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Bidiagonal{T}
+        @test C == B
+
+        B = Bidiagonal(A, :L)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Bidiagonal{T}
+        @test C == B
+
+        B = Tridiagonal(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Tridiagonal{T}
+        @test C == B
+
+        B = Hermitian(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Hermitian{T}
+        @test C == B
+
+        B = Symmetric(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Symmetric{T}
+        @test C == B
+
+        B = cholesky(AAt)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Cholesky{T}
+        @test C.factors == B.factors
+
+        pivot = VERSION < v"1.8.0-beta1" ? Val(true) : RowMaximum()
+        B = cholesky(AAt, pivot)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: CholeskyPivoted{T}
+        @test C.factors == B.factors
+
+        B = svd(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: SVD{T}
+        @test C.U == B.U
+        @test C.S == B.S
+        @test C.Vt == B.Vt
+
+        B = qr(A)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: Factorization{T}
+        @test C.Q == B.Q
+        @test C.R == B.R
+
+        pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? ColumnNorm() : Val(true)
+        B = qr(A, pivot)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: QRPivoted{T}
+        @test C.P == B.P
+        @test C.Q == B.Q
+        @test C.R == B.R
+        @test C.p == B.p
+
+        pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? NoPivot() : Val(false)
+        B = lu(A, pivot)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: LU{T}
+        @test C.L == B.L
+        @test C.U == B.U
+        @test C.P == B.P
+        @test C.p == B.p
+
+        pivot = isdefined(LinearAlgebra, :PivotingStrategy) ? RowMaximum() : Val(true)
+        B = lu(A, pivot)
+        @test eltype(B) == eltype(A) != T
+        @test @inferred(convert_eltype(eltype(B), B)) === B
+        C = @inferred convert_eltype(T, B)
+        @test typeof(C) <: LU{T}
+        @test C.L == B.L
+        @test C.U == B.U
+        @test C.P == B.P
+        @test C.p == B.p
+    end
+
     @testset "Unitful quantities" begin
         # bare_type for values
         @test Float64 === @inferred bare_type(u"2.0m/s")