Simplify implementation

Author: mtfishman

src/factorizations/orthnull.jl

@@ -1,94 +1,68 @@
 using MatrixAlgebraKit:
   MatrixAlgebraKit,
-  left_orth_polar!,
-  left_orth_qr!,
-  left_orth_svd!,
+  left_orth!,
   left_polar!,
   lq_compact!,
   qr_compact!,
-  right_orth_lq!,
-  right_orth_polar!,
-  right_orth_svd!,
+  right_orth!,
   right_polar!,
   select_algorithm,
   svd_compact!
 
-function MatrixAlgebraKit.left_orth!(
-  A::AbstractBlockSparseMatrix;
-  trunc=nothing,
-  kind=isnothing(trunc) ? :qr : :svd,
-  alg_qr=(; positive=true),
-  alg_polar=(;),
-  alg_svd=(;),
+function MatrixAlgebraKit.initialize_output(
+  ::typeof(left_orth!), A::AbstractBlockSparseMatrix
 )
-  if !isnothing(trunc) && kind != :svd
-    throw(ArgumentError("truncation not supported for `left_orth` with `kind=$kind`"))
-  end
-  if kind == :qr
-    return left_orth_qr!(A, alg_qr)
-  elseif kind == :polar
-    return left_orth_polar!(A, alg_polar)
-  elseif kind == :svd
-    return left_orth_svd!(A, alg_svd, trunc)
-  else
-    throw(ArgumentError("`left_orth` received unknown value `kind = $kind`"))
-  end
+  return nothing
 end
-function MatrixAlgebraKit.left_orth_qr!(A::AbstractBlockSparseMatrix, alg)
+function MatrixAlgebraKit.check_input(
+  ::typeof(left_orth!), A::AbstractBlockSparseMatrix, F::Nothing
+)
+  return nothing
+end
+
+function MatrixAlgebraKit.left_orth_qr!(A::AbstractBlockSparseMatrix, F, alg)
   alg′ = select_algorithm(qr_compact!, A, alg)
   return qr_compact!(A, alg′)
 end
-function MatrixAlgebraKit.left_orth_polar!(A::AbstractBlockSparseMatrix, alg)
+function MatrixAlgebraKit.left_orth_polar!(A::AbstractBlockSparseMatrix, F, alg)
   alg′ = select_algorithm(left_polar!, A, alg)
   return left_polar!(A, alg′)
 end
 function MatrixAlgebraKit.left_orth_svd!(
-  A::AbstractBlockSparseMatrix, alg, trunc::Nothing=nothing
+  A::AbstractBlockSparseMatrix, F, alg, trunc::Nothing=nothing
 )
   alg′ = select_algorithm(svd_compact!, A, alg)
   U, S, Vᴴ = svd_compact!(A, alg′)
   return U, S * Vᴴ
 end
 
-function MatrixAlgebraKit.right_orth!(
-  A::AbstractBlockSparseMatrix;
-  trunc=nothing,
-  kind=isnothing(trunc) ? :lq : :svd,
-  alg_lq=(; positive=true),
-  alg_polar=(;),
-  alg_svd=(;),
+function MatrixAlgebraKit.initialize_output(
+  ::typeof(right_orth!), A::AbstractBlockSparseMatrix
 )
-  if !isnothing(trunc) && kind != :svd
-    throw(ArgumentError("truncation not supported for `right_orth` with `kind=$kind`"))
-  end
-  if kind == :qr
-    # TODO: Implement this.
-    # return right_orth_lq!(A, alg_lq)
-    return right_orth_svd!(A, alg_svd)
-  elseif kind == :polar
-    return right_orth_polar!(A, alg_polar)
-  elseif kind == :svd
-    return right_orth_svd!(A, alg_svd, trunc)
-  else
-    throw(ArgumentError("`right_orth` received unknown value `kind = $kind`"))
-  end
+  return nothing
 end
-function MatrixAlgebraKit.right_orth_lq!(A::AbstractBlockSparseMatrix, alg)
-  alg′ = select_algorithm(lq_compact, A, alg)
+function MatrixAlgebraKit.check_input(
+  ::typeof(right_orth!), A::AbstractBlockSparseMatrix, F::Nothing
+)
+  return nothing
+end
+
+function MatrixAlgebraKit.right_orth_lq!(A::AbstractBlockSparseMatrix, F, alg)
+  alg′ = select_algorithm(lq_compact!, A, alg)
   return lq_compact!(A, alg′)
 end
-function MatrixAlgebraKit.right_orth_polar!(A::AbstractBlockSparseMatrix, alg)
+function MatrixAlgebraKit.right_orth_polar!(A::AbstractBlockSparseMatrix, F, alg)
   alg′ = select_algorithm(right_polar!, A, alg)
   return right_polar!(A, alg′)
 end
 function MatrixAlgebraKit.right_orth_svd!(
-  A::AbstractBlockSparseMatrix, alg, trunc::Nothing=nothing
+  A::AbstractBlockSparseMatrix, F, alg, trunc::Nothing=nothing
 )
   alg′ = select_algorithm(svd_compact!, A, alg)
   U, S, Vᴴ = svd_compact!(A, alg′)
   return U * S, Vᴴ
 end
-function MatrixAlgebraKit.right_orth_svd!(A::AbstractBlockSparseMatrix, alg, trunc)
+function MatrixAlgebraKit.right_orth_svd!(A::AbstractBlockSparseMatrix, F, alg, trunc)
   alg′ = select_algorithm(svd_compact!, A, alg)
   alg_trunc = select_algorithm(svd_trunc!, A, alg′; trunc)
   U, S, Vᴴ = svd_trunc!(A, alg_trunc)

src/factorizations/qr.jl

@@ -19,23 +19,6 @@ function MatrixAlgebraKit.default_algorithm(
   return default_blocksparse_qr_algorithm(A; kwargs...)
 end
 
-function default_blocksparse_lq_algorithm(A::AbstractMatrix; kwargs...)
-  blocktype(A) <: StridedMatrix{<:LinearAlgebra.BLAS.BlasFloat} ||
-    error("unsupported type: $(blocktype(A))")
-  alg = MatrixAlgebraKit.LAPACK_HouseholderLQ(; kwargs...)
-  return BlockPermutedDiagonalAlgorithm(alg)
-end
-function MatrixAlgebraKit.default_algorithm(
-  ::typeof(lq_compact!), A::AbstractBlockSparseMatrix; kwargs...
-)
-  return default_blocksparse_lq_algorithm(A; kwargs...)
-end
-function MatrixAlgebraKit.default_algorithm(
-  ::typeof(lq_full!), A::AbstractBlockSparseMatrix; kwargs...
-)
-  return default_blocksparse_lq_algorithm(A; kwargs...)
-end
-
 function similar_output(
   ::typeof(qr_compact!), A, R_axis, alg::MatrixAlgebraKit.AbstractAlgorithm
 )

test/test_factorizations.jl

@@ -250,7 +250,7 @@ end
   A[Block(1, 1)] = randn(T, 3, 2)
   A[Block(2, 2)] = randn(T, 4, 3)
 
-  for kind in (:qr, :polar, :svd)
+  for kind in (:polar, :qr, :svd)
     U, C = left_orth(A; kind)
     @test U * C ≈ A
     @test Matrix(U'U) ≈ LinearAlgebra.I
@@ -262,7 +262,7 @@ end
   A[Block(1, 1)] = randn(T, 2, 3)
   A[Block(2, 2)] = randn(T, 3, 4)
 
-  for kind in (:qr, :polar, :svd)
+  for kind in (:lq, :polar, :svd)
     C, U = right_orth(A; kind)
     @test C * U ≈ A
     @test Matrix(U * U') ≈ LinearAlgebra.I