Add comprehensive documentation for OpenBLASLUFactorization

- Add detailed docstring with performance characteristics and usage examples
- Include OpenBLASLUFactorization in solver documentation alongside MKL and AppleAccelerate
- Update algorithm selection guide to mention OpenBLAS as an option for large dense matrices
- Document when to use OpenBLAS vs other BLAS implementations

Author: claude

docs/src/basics/algorithm_selection.md

@@ -71,9 +71,10 @@ sol = solve(LinearProblem(A_small, rand(50)), SimpleLUFactorization())
 A_medium = rand(200, 200)
 sol = solve(LinearProblem(A_medium, rand(200)), RFLUFactorization())
 
-# Large matrices (> 500×500): MKLLUFactorization or AppleAccelerate
+# Large matrices (> 500×500): MKLLUFactorization, OpenBLASLUFactorization, or AppleAccelerate
 A_large = rand(1000, 1000) 
 sol = solve(LinearProblem(A_large, rand(1000)), MKLLUFactorization())
+# Alternative: OpenBLASLUFactorization() for direct OpenBLAS calls
 ```
 
 ### Sparse Matrices
@@ -141,7 +142,7 @@ Is A symmetric positive definite? → CholeskyFactorization
 Is A symmetric indefinite? → BunchKaufmanFactorization
 Is A sparse? → UMFPACKFactorization or KLUFactorization
 Is A small dense? → RFLUFactorization or SimpleLUFactorization
-Is A large dense? → MKLLUFactorization or AppleAccelerateLUFactorization
+Is A large dense? → MKLLUFactorization, OpenBLASLUFactorization, or AppleAccelerateLUFactorization
 Is A GPU array? → QRFactorization or LUFactorization
 Is A an operator/function? → KrylovJL_GMRES
 Is the system overdetermined? → QRFactorization or KrylovJL_LSMR

docs/src/solvers/solvers.md

@@ -17,9 +17,11 @@ 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.
+that `AppleAccelerateLUFactorization` is generally always the fastest. `OpenBLASLUFactorization` 
+provides direct OpenBLAS calls without going through libblastrampoline and can be faster than 
+`LUFactorization` in some configurations. `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
@@ -207,6 +209,12 @@ KrylovJL
 MKLLUFactorization
 ```
 
+### OpenBLAS
+
+```@docs
+OpenBLASLUFactorization
+```
+
 ### AppleAccelerate.jl
 
 !!! note

src/openblas.jl

@@ -3,8 +3,33 @@
 OpenBLASLUFactorization()
 ```
 
-A wrapper over OpenBLAS. Direct calls to OpenBLAS in a way that pre-allocates workspace
-to avoid allocations and does not require libblastrampoline.
+A direct wrapper over OpenBLAS's LU factorization (`getrf!` and `getrs!`). 
+This solver makes direct calls to OpenBLAS_jll without going through Julia's 
+libblastrampoline, which can provide performance benefits in certain configurations.
+
+## Performance Characteristics
+
+- Pre-allocates workspace to avoid allocations during solving
+- Makes direct `ccall`s to OpenBLAS routines
+- Can be faster than `LUFactorization` when OpenBLAS is well-optimized for the hardware
+- Supports `Float32`, `Float64`, `ComplexF32`, and `ComplexF64` element types
+
+## When to Use
+
+- When you want to ensure OpenBLAS is used regardless of the system BLAS configuration
+- When benchmarking shows better performance than `LUFactorization` on your specific hardware
+- When you need consistent behavior across different systems (always uses OpenBLAS)
+
+## Example
+
+```julia
+using LinearSolve, LinearAlgebra
+
+A = rand(100, 100)
+b = rand(100)
+prob = LinearProblem(A, b)
+sol = solve(prob, OpenBLASLUFactorization())
+```
 """
 struct OpenBLASLUFactorization <: AbstractFactorization end