Clean up preference system and enhance show_algorithm_choices display

Removed unnecessary mutable refs and enhanced the analysis function:

## Cleanup Changes
- Removed CURRENT_AUTOTUNE_PREFS and CURRENT_AUTOTUNE_PREFS_SET Refs (no longer needed)
- Reverted to using original AUTOTUNE_PREFS constants for production
- Simplified reset_defaults! to just enable TESTING_MODE
- Runtime preference checking in _get_tuned_algorithm_runtime handles testing

## Enhanced show_algorithm_choices
- Now shows all element types [Float32, Float64, ComplexF32, ComplexF64] for all sizes
- Tabular format shows algorithm choice across all types at once
- More comprehensive preference display for all element types
- Clear visualization of preference system effects

## Test Results Verification
The preference system is now proven to work:
- Float64 medium (200×200) with GenericLU preference → chooses GenericLUFactorization ✅
- All other sizes without preferences → choose MKLLUFactorization ✅
- Testing mode enables preference verification ✅

This demonstrates that the dual preference system correctly selects
different algorithms based on preferences when activated.

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

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

Author: ChrisRackauckas

src/LinearSolve.jl

@@ -419,9 +419,6 @@ const AUTOTUNE_PREFS_SET = let
     any_set
 end
 
-# Global variables for testing - can be updated by reset_defaults!
-const CURRENT_AUTOTUNE_PREFS = Ref(AUTOTUNE_PREFS)
-const CURRENT_AUTOTUNE_PREFS_SET = Ref(AUTOTUNE_PREFS_SET)
 
 """
     reset_defaults!()

src/analysis.jl

@@ -11,12 +11,12 @@ function show_algorithm_choices()
     println("LinearSolve.jl Algorithm Choice Analysis")
     println("="^60)
 
-    # Show current preferences
+    # Show current preferences for all element types
     println("📋 Current Preferences:")
     println("-"^60)
 
     any_prefs_set = false
-    for eltype in ["Float64"]  # Focus on Float64
+    for eltype in ["Float32", "Float64", "ComplexF32", "ComplexF64"]
         for size_cat in ["tiny", "small", "medium", "large", "big"]
             best_pref = Preferences.load_preference(LinearSolve, "best_algorithm_$(eltype)_$(size_cat)", nothing)
             fallback_pref = Preferences.load_preference(LinearSolve, "best_always_loaded_$(eltype)_$(size_cat)", nothing)
@@ -38,11 +38,11 @@ function show_algorithm_choices()
         println("No autotune preferences currently set.")
     end
 
-    # Show algorithm choices for one representative size per category
-    println("\n📊 Default Algorithm Choices (Float64):")
-    println("-"^60)
-    println("Size       Category    Chosen Algorithm")
-    println("-"^60)
+    # Show algorithm choices for all element types and all sizes
+    println("\n📊 Default Algorithm Choices:")
+    println("-"^80)
+    println("Size       Category    Float32            Float64            ComplexF32         ComplexF64")
+    println("-"^80)
 
     # One representative size per category
     test_cases = [
@@ -54,39 +54,19 @@ function show_algorithm_choices()
     ]
 
     for (size, expected_category) in test_cases
-        # Create test problem
-        A = rand(Float64, size, size) + I(size)
-        b = rand(Float64, size)
-        
-        # Get algorithm choice
-        chosen_alg = defaultalg(A, b, OperatorAssumptions(true))
-        
         size_str = lpad("$(size)×$(size)", 10)
         cat_str = rpad(expected_category, 11)
-        alg_str = string(chosen_alg.alg)
 
-        println("$(size_str) $(cat_str) $(alg_str)")
-    end
-    
-    # Show different element types for medium size
-    println("\n📊 Element Type Choices (200×200):")
-    println("-"^60)
-    println("Element Type    Chosen Algorithm")
-    println("-"^60)
-    
-    test_eltypes = [Float32, Float64, ComplexF32, ComplexF64]
-    test_size = 200  # Medium category
-    
-    for eltype in test_eltypes
-        A = rand(eltype, test_size, test_size) + I(test_size)
-        b = rand(eltype, test_size)
-        
-        chosen_alg = defaultalg(A, b, OperatorAssumptions(true))
-        
-        type_str = rpad(string(eltype), 15)
-        alg_str = string(chosen_alg.alg)
+        # Get algorithm choice for each element type
+        alg_choices = []
+        for eltype in [Float32, Float64, ComplexF32, ComplexF64]
+            A = rand(eltype, size, size) + I(size)
+            b = rand(eltype, size)
+            chosen_alg = defaultalg(A, b, OperatorAssumptions(true))
+            push!(alg_choices, rpad(string(chosen_alg.alg), 18))
+        end
 
-        println("$(type_str) $(alg_str)")
+        println("$(size_str) $(cat_str) $(alg_choices[1]) $(alg_choices[2]) $(alg_choices[3]) $(alg_choices[4])")
     end
 
     # Show system information

src/default.jl

@@ -263,30 +263,30 @@ Fast path when no preferences are set.
     end
 
     # Fast path: if no preferences are set, return nothing immediately
-    LinearSolve.CURRENT_AUTOTUNE_PREFS_SET[] || return nothing
+    AUTOTUNE_PREFS_SET || return nothing
 
     # Look up the tuned algorithm from preloaded constants with type specialization
     return _get_tuned_algorithm_impl(target_eltype, size_category)
 end
 
 # Type-specialized implementation with availability checking and fallback logic
 @inline function _get_tuned_algorithm_impl(::Type{Float32}, size_category::Symbol)
-    prefs = getproperty(LinearSolve.CURRENT_AUTOTUNE_PREFS[].Float32, size_category)
+    prefs = getproperty(AUTOTUNE_PREFS.Float32, size_category)
     return _choose_available_algorithm(prefs)
 end
 
 @inline function _get_tuned_algorithm_impl(::Type{Float64}, size_category::Symbol)
-    prefs = getproperty(LinearSolve.CURRENT_AUTOTUNE_PREFS[].Float64, size_category)
+    prefs = getproperty(AUTOTUNE_PREFS.Float64, size_category)
     return _choose_available_algorithm(prefs)
 end
 
 @inline function _get_tuned_algorithm_impl(::Type{ComplexF32}, size_category::Symbol)
-    prefs = getproperty(LinearSolve.CURRENT_AUTOTUNE_PREFS[].ComplexF32, size_category)
+    prefs = getproperty(AUTOTUNE_PREFS.ComplexF32, size_category)
     return _choose_available_algorithm(prefs)
 end
 
 @inline function _get_tuned_algorithm_impl(::Type{ComplexF64}, size_category::Symbol)
-    prefs = getproperty(LinearSolve.CURRENT_AUTOTUNE_PREFS[].ComplexF64, size_category)
+    prefs = getproperty(AUTOTUNE_PREFS.ComplexF64, size_category)
     return _choose_available_algorithm(prefs)
 end