Revert "Apply JuliaFormatter to modified files"

This reverts commit 875dd22.

Author: ChrisRackauckas

lib/LinearSolveAutotune/src/benchmarking.jl

@@ -13,38 +13,37 @@ Uses more strict rules for BLAS-dependent algorithms with non-standard types.
 function test_algorithm_compatibility(alg, eltype::Type, test_size::Int = 4)
     # Get algorithm name for type-specific compatibility rules
     alg_name = string(typeof(alg).name.name)
-
+    
     # Define strict compatibility rules for BLAS-dependent algorithms
-    if !(eltype <: LinearAlgebra.BLAS.BlasFloat) && alg_name in [
-        "BLISFactorization", "MKLLUFactorization", "AppleAccelerateLUFactorization"]
+    if !(eltype <: LinearAlgebra.BLAS.BlasFloat) && alg_name in ["BLISFactorization", "MKLLUFactorization", "AppleAccelerateLUFactorization"]
         return false  # BLAS algorithms not compatible with non-standard types
     end
 
     if alg_name == "BLISLUFactorization" && Sys.isapple()
         return false  # BLISLUFactorization has no Apple Silicon binary
     end
-
+    
     # For standard types or algorithms that passed the strict check, test functionality
     try
         # Create a small test problem with the specified element type
         rng = MersenneTwister(123)
         A = rand(rng, eltype, test_size, test_size)
         b = rand(rng, eltype, test_size)
         u0 = rand(rng, eltype, test_size)
-
+        
         prob = LinearProblem(A, b; u0 = u0)
-
+        
         # Try to solve - if it works, the algorithm is compatible
         sol = solve(prob, alg)
-
+        
         # Additional check: verify the solution is actually of the expected type
         if !isa(sol.u, AbstractVector{eltype})
             @debug "Algorithm $alg_name returned wrong element type for $eltype"
             return false
         end
-
+        
         return true
-
+        
     catch e
         # Algorithm failed - not compatible with this element type
         @debug "Algorithm $alg_name failed for $eltype: $e"
@@ -61,14 +60,14 @@ Returns filtered algorithms and names.
 function filter_compatible_algorithms(algorithms, alg_names, eltype::Type)
     compatible_algs = []
     compatible_names = String[]
-
+    
     for (alg, name) in zip(algorithms, alg_names)
         if test_algorithm_compatibility(alg, eltype)
             push!(compatible_algs, alg)
             push!(compatible_names, name)
         end
     end
-
+    
     return compatible_algs, compatible_names
 end
 
@@ -90,37 +89,36 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
     # Initialize results DataFrame
     results_data = []
-
+    
     # Calculate total number of benchmarks for progress bar
     total_benchmarks = 0
     for eltype in eltypes
         # Pre-filter to estimate the actual number
         test_algs, _ = filter_compatible_algorithms(algorithms, alg_names, eltype)
         total_benchmarks += length(matrix_sizes) * length(test_algs)
     end
-
+    
     # Create progress bar
-    progress = Progress(total_benchmarks, desc = "Benchmarking: ",
-        barlen = 50, showspeed = true)
+    progress = Progress(total_benchmarks, desc="Benchmarking: ", 
+                       barlen=50, showspeed=true)
 
     try
         for eltype in eltypes
             # Filter algorithms for this element type
-            compatible_algs,
-            compatible_names = filter_compatible_algorithms(algorithms, alg_names, eltype)
-
+            compatible_algs, compatible_names = filter_compatible_algorithms(algorithms, alg_names, eltype)
+            
             if isempty(compatible_algs)
                 @warn "No algorithms compatible with $eltype, skipping..."
                 continue
             end
-
+            
             for n in matrix_sizes
                 # Create test problem with specified element type
                 rng = MersenneTwister(123)  # Consistent seed for reproducibility
                 A = rand(rng, eltype, n, n)
                 b = rand(rng, eltype, n)
                 u0 = rand(rng, eltype, n)
-
+                
                 # Compute reference solution with LUFactorization if correctness check is enabled
                 reference_solution = nothing
                 if check_correctness
@@ -135,9 +133,9 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
                 for (alg, name) in zip(compatible_algs, compatible_names)
                     # Update progress description
-                    ProgressMeter.update!(progress,
-                        desc = "Benchmarking $name on $(n)×$(n) $eltype matrix: ")
-
+                    ProgressMeter.update!(progress, 
+                        desc="Benchmarking $name on $(n)×$(n) $eltype matrix: ")
+                    
                     gflops = 0.0
                     success = true
                     error_msg = ""
@@ -151,13 +149,12 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
 
                         # Warmup run and correctness check
                         warmup_sol = solve(prob, alg)
-
+                        
                         # Check correctness if reference solution is available
                         if check_correctness && reference_solution !== nothing
                             # Compute relative error
-                            rel_error = norm(warmup_sol.u - reference_solution.u) /
-                                        norm(reference_solution.u)
-
+                            rel_error = norm(warmup_sol.u - reference_solution.u) / norm(reference_solution.u)
+                            
                             if rel_error > correctness_tol
                                 passed_correctness = false
                                 @warn "Algorithm $name failed correctness check for size $n, eltype $eltype. " *
@@ -167,7 +164,7 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
                                 error_msg = "Failed correctness check (rel_error = $(round(rel_error, sigdigits=3)))"
                             end
                         end
-
+                        
                         # Only benchmark if correctness check passed
                         if passed_correctness
                             # Actual benchmark
@@ -198,7 +195,7 @@ function benchmark_algorithms(matrix_sizes, algorithms, alg_names, eltypes;
                             success = success,
                             error = error_msg
                         ))
-
+                    
                     # Update progress
                     ProgressMeter.next!(progress)
                 end
@@ -219,16 +216,15 @@ end
 Get the matrix sizes to benchmark based on the requested size categories.
 
 Size categories:
-
-  - `:tiny` - 5:5:20 (for very small problems)
-  - `:small` - 20:20:100 (for small problems)
-  - `:medium` - 100:50:300 (for typical problems)
-  - `:large` - 300:100:1000 (for larger problems)
-  - `:big` - vcat(1000:2000:10000, 10000:5000:20000) (for very large/GPU problems)
+- `:tiny` - 5:5:20 (for very small problems)
+- `:small` - 20:20:100 (for small problems)
+- `:medium` - 100:50:300 (for typical problems)
+- `:large` - 300:100:1000 (for larger problems)
+- `:big` - vcat(1000:2000:10000, 10000:5000:20000) (for very large/GPU problems)
 """
 function get_benchmark_sizes(size_categories::Vector{Symbol})
     sizes = Int[]
-
+    
     for category in size_categories
         if category == :tiny
             append!(sizes, 5:5:20)
@@ -244,7 +240,7 @@ function get_benchmark_sizes(size_categories::Vector{Symbol})
             @warn "Unknown size category: $category. Skipping."
         end
     end
-
+    
     # Remove duplicates and sort
     return sort(unique(sizes))
 end
@@ -281,10 +277,10 @@ function categorize_results(df::DataFrame)
 
     for eltype in eltypes
         @info "Categorizing results for element type: $eltype"
-
+        
         # Filter results for this element type
         eltype_df = filter(row -> row.eltype == eltype, successful_df)
-
+        
         if nrow(eltype_df) == 0
             continue
         end
@@ -299,27 +295,24 @@ function categorize_results(df::DataFrame)
 
             # Calculate average GFLOPs for each algorithm in this range
             avg_results = combine(groupby(range_df, :algorithm), :gflops => mean => :avg_gflops)
-
+            
             # Sort by performance
-            sort!(avg_results, :avg_gflops, rev = true)
+            sort!(avg_results, :avg_gflops, rev=true)
 
             # Find the best algorithm (for complex types, avoid RFLU if possible)
             if nrow(avg_results) > 0
                 best_alg = avg_results.algorithm[1]
-
+                
                 # For complex types, check if best is RFLU and we have alternatives
-                if (eltype == "ComplexF32" || eltype == "ComplexF64") &&
-                   (contains(best_alg, "RFLU") ||
-                    contains(best_alg, "RecursiveFactorization"))
-
+                if (eltype == "ComplexF32" || eltype == "ComplexF64") && 
+                   (contains(best_alg, "RFLU") || contains(best_alg, "RecursiveFactorization"))
+                    
                     # Look for the best non-RFLU algorithm
                     for i in 2:nrow(avg_results)
                         alt_alg = avg_results.algorithm[i]
-                        if !contains(alt_alg, "RFLU") &&
-                           !contains(alt_alg, "RecursiveFactorization")
+                        if !contains(alt_alg, "RFLU") && !contains(alt_alg, "RecursiveFactorization")
                             # Check if performance difference is not too large (within 20%)
-                            perf_ratio = avg_results.avg_gflops[i] /
-                                         avg_results.avg_gflops[1]
+                            perf_ratio = avg_results.avg_gflops[i] / avg_results.avg_gflops[1]
                             if perf_ratio > 0.8
                                 @info "Using $alt_alg instead of $best_alg for $eltype at $range_name ($(round(100*perf_ratio, digits=1))% of RFLU performance) to avoid complex number issues"
                                 best_alg = alt_alg
@@ -330,7 +323,7 @@ function categorize_results(df::DataFrame)
                         end
                     end
                 end
-
+                
                 category_key = "$(eltype)_$(range_name)"
                 categories[category_key] = best_alg
                 best_idx = findfirst(==(best_alg), avg_results.algorithm)