Bound the UMFPACK-backed sparse cachevals to the eltypes UMFPACK has (#1122)

`init(LinearProblem(A, b), nothing)` throws for a Float32 sparse matrix on
main:

    defaultalg(...)  = DefaultLinearSolver(DefaultAlgorithmChoice.KLUFactorization, ...)
    init(...)        = MethodError: no method matching
                       SparseArrays.UMFPACK.UmfpackLU(::SparseMatrixCSC{Float32, Int64})

Note the algorithm that throws is not the one selected. `_init_default_cacheval`
(src/default.jl, @generated) emits an unconditional `init_cacheval` for every
slot - only the three Krylov slots are guarded - so a too-permissive
`init_cacheval` on an *unselected* algorithm still breaks `init`. KLU is
chosen; the `LUFactorization` slot is built first and throws.

`LUFactorization`'s and `UMFPACKFactorization`'s sparse cachevals are bounded
by `BLASELTYPES = Union{Float32, Float64, ComplexF32, ComplexF64}`, but
UMFPACK's `UmfpackLU` exists only for Float64/ComplexF64 (SuiteSparse's
`UMFVTypes`), so the bound is too wide by exactly Float32/ComplexF32. KLU
already does this correctly with `T <: KLU.KLUTypes`.

Bound them to a local `UMFPACKELTYPES` instead. The additional `BLASELTYPES`
method is not redundant: the old methods' `is_cusparse(A)` branch is the only
`LUFactorization`+CuSparse `init_cacheval` in the tree, so narrowing alone
would have silently dropped Float32 cuDSS support. `UMFPACKELTYPES` is defined
locally rather than reusing `SparseArrays.UMFPACK.UMFVTypes`, which is a
non-public internal.

Float32/ComplexF32 sparse now resolve to the `KLUFactorization` slot, which
`algchoice_to_alg` maps to `PureKLUFactorization()` - pure Julia, and the only
thing in the tree that supports these eltypes. It is a hard dependency, so no
extra `using` is needed.

Two separate breakages, both bisected:

  0ce03c2  2025-05-22
    widened the cachevals to `T <: BLASELTYPES` while adding ComplexF64.
    Broke Float32 sparse for Sparspak users; everyone else still hit the
    "using Sparspak required" error in `defaultalg` first, so it stayed hidden.

  52ebf25  (#1037)  2026-06-13
    removed that early error, exposing the breakage to everyone.

Measured before/after, all 10 eltype/index combinations:

  before: Float32 and ComplexF32 (Int64 and Int32) all `INIT THREW`
  after:  all 10 solve, residual 0, eltype preserved (no Float64 promotion)

Explicitly-requested `LUFactorization`/`UMFPACKFactorization` on Float32
sparse remain unsupported, as before this change - they now fail the way
SuiteSparse KLU already does for an unsupported eltype rather than with a
`MethodError`. Making them work would mean silent Float32->Float64 promotion,
which is a behavior addition, not a bug fix.

`Test.detect_ambiguities` on the extension: 12 before, 12 after.
GROUP=Core passes on the fixed tree and on unmodified main.



Claude-Session: https://claude.ai/code/session_017rr42T1vFRRT8D7DMAmJzf

Co-authored-by: ChrisRackauckas-Claude <accounts@chrisrackauckas.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: 3 people

ext/LinearSolveSparseArraysExt.jl

@@ -128,6 +128,11 @@ end
     )
 end # @static if Base.USE_GPL_LIBS
 
+# UMFPACK's `UmfpackLU` only exists for `Float64`/`ComplexF64` (SuiteSparse's
+# `UMFVTypes`). The other BLAS eltypes are not a subset of it, so cachevals for
+# UMFPACK-backed algorithms must be bounded by this, not by `BLASELTYPES`.
+const UMFPACKELTYPES = Union{Float64, ComplexF64}
+
 function LinearSolve.init_cacheval(
         alg::LUFactorization, A::AbstractSparseArray{<:Number, <:Integer}, b, u,
         Pl, Pr,
@@ -169,7 +174,7 @@ end
             Pl, Pr,
             maxiters::Int, abstol, reltol,
             verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions
-        ) where {T <: BLASELTYPES}
+        ) where {T <: UMFPACKELTYPES}
         if LinearSolve.is_cusparse(A)
             LinearSolve.cudss_loaded(A) ? ArrayInterface.lu_instance(A) : nothing
         else
@@ -185,7 +190,7 @@ end
             Pl, Pr,
             maxiters::Int, abstol, reltol,
             verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions
-        ) where {T <: BLASELTYPES}
+        ) where {T <: UMFPACKELTYPES}
         if LinearSolve.is_cusparse(A)
             LinearSolve.cudss_loaded(A) ? ArrayInterface.lu_instance(A) : nothing
         else
@@ -198,6 +203,21 @@ end
     end
 end # @static if Base.USE_GPL_LIBS
 
+# Single-precision sparse: no UMFPACK cacheval exists, but a cuDSS-backed
+# CuSparse matrix still needs its `lu_instance`.
+function LinearSolve.init_cacheval(
+        alg::LUFactorization, A::AbstractSparseArray{T, <:Union{Int32, Int64}}, b, u,
+        Pl, Pr,
+        maxiters::Int, abstol, reltol,
+        verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions
+    ) where {T <: BLASELTYPES}
+    if LinearSolve.is_cusparse(A)
+        return LinearSolve.cudss_loaded(A) ? ArrayInterface.lu_instance(A) : nothing
+    else
+        return nothing
+    end
+end
+
 function LinearSolve.init_cacheval(
         alg::LUFactorization, A::LinearSolve.GPUArraysCore.AnyGPUArray, b, u,
         Pl, Pr,
@@ -231,7 +251,7 @@ end
             Pl, Pr,
             maxiters::Int, abstol, reltol,
             verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions
-        ) where {T <: BLASELTYPES}
+        ) where {T <: UMFPACKELTYPES}
         SparseArrays.UMFPACK.UmfpackLU(
             SparseMatrixCSC{T, Int64}(
                 zero(Int64), zero(Int64), [Int64(1)], Int64[], T[]
@@ -244,7 +264,7 @@ end
             Pl, Pr,
             maxiters::Int, abstol, reltol,
             verbose::Union{LinearVerbosity, Bool}, assumptions::OperatorAssumptions
-        ) where {T <: BLASELTYPES}
+        ) where {T <: UMFPACKELTYPES}
         SparseArrays.UMFPACK.UmfpackLU(
             SparseMatrixCSC{T, Int32}(
                 zero(Int32), zero(Int32), [Int32(1)], Int32[], T[]

test/Core/default_algs.jl

@@ -115,6 +115,25 @@ let As_bf = sparse(BigFloat.([1 2 3; 2 4 6; 1 1 1])), bs_bf = BigFloat.([1, 2, 3
     @test all(isfinite, sol.u)
 end
 
+# Single-precision sparse has no UMFPACK/KLU (SuiteSparse) support, so the
+# default polyalgorithm — which eagerly builds a cacheval for *every* slot, not
+# just the selected one — must not try to allocate an UMFPACK cacheval for it.
+@testset "Sparse $T with $Ti indices" for T in (Float32, ComplexF32),
+        Ti in (Int64, Int32)
+
+    n = 20
+    A32 = sparse(Ti.(1:n), Ti.(1:n), fill(T(n), n), n, n) +
+        sparse(Ti.(1:(n - 1)), Ti.(2:n), fill(T(1), n - 1), n, n)
+    b32 = ones(T, n)
+    @test A32 isa SparseMatrixCSC{T, Ti}
+    @test LinearSolve.defaultalg(A32, b32, LinearSolve.OperatorAssumptions(true)).alg ===
+        LinearSolve.DefaultAlgorithmChoice.KLUFactorization
+    sol32 = solve(LinearProblem(A32, b32))
+    @test SciMLBase.successful_retcode(sol32.retcode)
+    @test eltype(sol32.u) === T
+    @test norm(A32 * sol32.u - b32) / norm(b32) < 1.0f-5
+end
+
 @test LinearSolve.defaultalg(sprand(10^4, 10^4, 1.0e-5) + I, zeros(1000)).alg ===
     LinearSolve.DefaultAlgorithmChoice.KLUFactorization
 prob = LinearProblem(sprand(1000, 1000, 0.5), zeros(1000))