Add 32-bit mixed precision solvers for OpenBLAS and RecursiveFactorization

[ChrisRackauckas-Claude]

Summary

• Adds OpenBLAS32MixedLUFactorization for mixed precision LU factorization using OpenBLAS
• Adds RF32MixedLUFactorization for mixed precision LU factorization using RecursiveFactorization.jl
• Includes comprehensive test coverage for both new solvers

Motivation

This PR extends LinearSolve.jl's mixed precision solver offerings by adding 32-bit mixed precision implementations for OpenBLAS and RecursiveFactorization, complementing the existing MKL and AppleAccelerate mixed precision solvers. These solvers provide significant performance benefits for memory-bandwidth limited problems while maintaining acceptable accuracy for many use cases.

Implementation Details

OpenBLAS32MixedLUFactorization

• Performs LU factorization in Float32 precision using OpenBLAS routines
• Automatically converts Float64 inputs to Float32 for factorization
• Converts results back to Float64 for the solution
• Supports both real and complex matrices (Float64/ComplexF64 → Float32/ComplexF32)

RF32MixedLUFactorization

• Leverages RecursiveFactorization.jl's optimized blocking strategies in Float32 precision
• Particularly effective for small to medium matrices (< 500×500)
• Supports pivoting options (can disable for additional speed at cost of stability)
• Threading support for multi-core performance

Performance Benefits

• Can provide ~2x speedup for memory-bandwidth limited problems
• Reduces memory usage during factorization
• Particularly beneficial for:
  • Large systems where memory bandwidth is the bottleneck
  • Iterative algorithms where moderate precision is acceptable
  • Problems with well-conditioned matrices

Testing

• Added comprehensive tests in test/test_mixed_precision.jl
• Tests verify:
  • Successful factorization and solve
  • Reasonable accuracy compared to full precision (relative error < 1e-5)
  • Support for both real and complex matrices
  • Proper handling when libraries are not available

Compatibility

• Follows the same API pattern as existing mixed precision solvers
• No breaking changes
• Gracefully handles cases where OpenBLAS or RecursiveFactorization are not available

Example Usage

using LinearSolve, RecursiveFactorization

A = rand(1000, 1000)
b = rand(1000)
prob = LinearProblem(A, b)

# OpenBLAS mixed precision
sol1 = solve(prob, OpenBLAS32MixedLUFactorization())

# RecursiveFactorization mixed precision
sol2 = solve(prob, RF32MixedLUFactorization())

# Without pivoting for maximum speed (less stable)
sol3 = solve(prob, RF32MixedLUFactorization(pivot=Val(false)))

🤖 Generated with Claude Code

[ChrisRackauckas-Claude]

I've pushed an additional commit that fixes the tests. The mixed precision algorithms need higher tolerance (atol=1e-5, rtol=1e-5) compared to full precision methods since they perform calculations in Float32 precision. This is expected behavior and consistent with the tolerances used for the existing MKL and AppleAccelerate mixed precision solvers.

[ChrisRackauckas-Claude]

I've pushed additional fixes to address the test failures:

1. Updated resolve.jl tests: Added proper handling for mixed precision algorithms with appropriate tolerances and availability checks
2. Applied code formatting: Formatted the changed files with JuliaFormatter using SciMLStyle
3. Fixed test compatibility: Added proper checks for when RecursiveFactorization and OpenBLAS are available

The mixed precision algorithms are now properly integrated with the test suite and should pass CI checks.