Add comprehensive documentation and finalize BLIS integration

- Add blis_jll as test dependency in Project.toml
- Remove LAPACK_jll from test imports (not needed for user tests)
- Add comprehensive docstring for BLISLUFactorization
- Add module-level documentation for LinearSolveBLISExt
- Add BLIS section to solver documentation
- Include BLIS in recommended methods section
- Add docstring for do_factorization method

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: claude

Project.toml

@@ -129,6 +129,7 @@ Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 ExplicitImports = "7d51a73a-1435-4ff3-83d9-f097790105c7"
 BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0"
+blis_jll = "6136c539-28a5-5bf0-87cc-b183200dce32"
 FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e"
 FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641"
 FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41"
@@ -155,4 +156,4 @@ Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [targets]
-test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "FastLapackInterface", "SparseArrays", "ExplicitImports"]
+test = ["Aqua", "Test", "IterativeSolvers", "InteractiveUtils", "KrylovKit", "KrylovPreconditioners", "Pkg", "Random", "SafeTestsets", "MultiFloats", "ForwardDiff", "HYPRE", "MPI", "BlockDiagonals", "FiniteDiff", "BandedMatrices", "blis_jll", "FastAlmostBandedMatrices", "StaticArrays", "AllocCheck", "StableRNGs", "Zygote", "RecursiveFactorization", "Sparspak", "FastLapackInterface", "SparseArrays", "ExplicitImports"]

docs/src/solvers/solvers.md

@@ -16,10 +16,12 @@ the best choices, with SVD being the slowest but most precise.
 
 For efficiency, `RFLUFactorization` is the fastest for dense LU-factorizations until around
 150x150 matrices, though this can be dependent on the exact details of the hardware. After this
-point, `MKLLUFactorization` is usually faster on most hardware. Note that on Mac computers
-that `AppleAccelerateLUFactorization` is generally always the fastest. `LUFactorization` will
-use your base system BLAS which can be fast or slow depending on the hardware configuration.
-`SimpleLUFactorization` will be fast only on very small matrices but can cut down on compile times.
+point, `MKLLUFactorization` is usually faster on most hardware. `BLISLUFactorization` provides
+another high-performance option that combines optimized BLAS operations with stable LAPACK routines.
+Note that on Mac computers that `AppleAccelerateLUFactorization` is generally always the fastest. 
+`LUFactorization` will use your base system BLAS which can be fast or slow depending on the hardware 
+configuration. `SimpleLUFactorization` will be fast only on very small matrices but can cut down on 
+compile times.
 
 For very large dense factorizations, offloading to the GPU can be preferred. Metal.jl can be used
 on Mac hardware to offload, and has a cutoff point of being faster at around size 20,000 x 20,000
@@ -185,6 +187,17 @@ KrylovJL
 MKLLUFactorization
 ```
 
+### BLIS.jl
+
+!!! note
+    
+    Using this solver requires that the package blis_jll is available. The solver will 
+    be automatically available when blis_jll is loaded, i.e., `using blis_jll`.
+
+```@docs
+BLISLUFactorization
+```
+
 ### AppleAccelerate.jl
 
 !!! note

ext/LinearSolveBLISExt.jl

@@ -1,3 +1,17 @@
+"""
+LinearSolveBLISExt
+
+Extension module that provides BLIS (BLAS-like Library Instantiation Software) integration
+for LinearSolve.jl. This extension combines BLIS for optimized BLAS operations with 
+reference LAPACK for LAPACK operations, providing a high-performance yet stable linear 
+algebra backend.
+
+Key features:
+- Uses BLIS for BLAS operations (matrix multiplication, etc.)
+- Uses reference LAPACK for LAPACK operations (LU factorization, solve, etc.)
+- Supports all standard numeric types (Float32/64, ComplexF32/64)
+- Follows MKL-style ccall patterns for consistency
+"""
 module LinearSolveBLISExt
 
 using Libdl
@@ -14,7 +28,12 @@ using LinearSolve: ArrayInterface, BLISLUFactorization, @get_cacheval, LinearCac
 const global libblis = blis_jll.blis
 const global liblapack = LAPACK_jll.liblapack_path
 
-# Define the factorization method for BLISLUFactorization
+"""
+    LinearSolve.do_factorization(alg::BLISLUFactorization, A, b, u)
+
+Perform LU factorization using BLIS for the underlying BLAS operations.
+This method converts the matrix to a standard format and calls the BLIS-backed getrf! routine.
+"""
 function LinearSolve.do_factorization(alg::BLISLUFactorization, A, b, u)
     A = convert(AbstractMatrix, A)
     ipiv = similar(A, BlasInt, min(size(A, 1), size(A, 2)))

src/extension_algs.jl

@@ -440,4 +440,39 @@ to avoid allocations and automatically offloads to the GPU.
 """
 struct MetalLUFactorization <: AbstractFactorization end
 
+"""
+```julia
+BLISLUFactorization()
+```
+
+A wrapper over BLIS (BLAS-like Library Instantiation Software) for high-performance 
+BLAS operations combined with reference LAPACK for stability. This provides optimized 
+linear algebra operations while maintaining numerical accuracy and broad compatibility.
+
+BLIS provides highly optimized BLAS routines that can outperform reference BLAS 
+implementations, especially for certain matrix sizes and operations. The integration 
+uses BLIS for BLAS operations (like matrix multiplication) and falls back to reference 
+LAPACK for LAPACK operations (like LU factorization and solve).
+
+!!! note
+
+    Using this solver requires that the package blis_jll is available. The solver will 
+    be automatically available when blis_jll is loaded, i.e., `using blis_jll`.
+
+## Performance Characteristics
+
+- **Strengths**: Optimized BLAS operations, good performance on modern hardware
+- **Use cases**: General dense linear systems where BLAS optimization matters
+- **Compatibility**: Works with all numeric types (Float32/64, Complex32/64)
+
+## Example
+
+```julia
+using LinearSolve, blis_jll
+A = rand(100, 100)
+b = rand(100)
+prob = LinearProblem(A, b)
+sol = solve(prob, BLISLUFactorization())
+```
+"""
 struct BLISLUFactorization <: AbstractFactorization end

test/basictests.jl

@@ -4,7 +4,7 @@ using IterativeSolvers, KrylovKit, MKL_jll, KrylovPreconditioners
 using Test
 
 # Import JLL packages for extensions
-using blis_jll, LAPACK_jll
+using blis_jll
 import Random
 
 const Dual64 = ForwardDiff.Dual{Nothing, Float64, 1}