Use JuliaFormatter on the modified files

Author: amontoison

src/graph.jl

@@ -236,16 +236,20 @@ function AdjacencyGraph(
     S::SparsityPatternCSC{T},
     edge_to_index::Vector{T}=build_edge_to_index(S);
     augmented_graph::Bool=false,
-    original_size::Tuple{Int,Int}=size(S),    
+    original_size::Tuple{Int,Int}=size(S),
 ) where {T}
     return AdjacencyGraph{T,augmented_graph}(S, edge_to_index, original_size)
 end
 
-function AdjacencyGraph(A::SparseMatrixCSC; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A))
+function AdjacencyGraph(
+    A::SparseMatrixCSC; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A)
+)
     return AdjacencyGraph(SparsityPatternCSC(A); augmented_graph)
 end
 
-function AdjacencyGraph(A::AbstractMatrix; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A))
+function AdjacencyGraph(
+    A::AbstractMatrix; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A)
+)
     return AdjacencyGraph(SparseMatrixCSC(A); augmented_graph)
 end
 

src/interface.jl

@@ -112,7 +112,9 @@ struct GreedyColoringAlgorithm{decompression,N,O<:NTuple{N,AbstractOrder}} <:
         else
             orders = order_or_orders
         end
-        return new{decompression,length(orders),typeof(orders)}(orders, postprocessing, postprocessing_minimizes)
+        return new{decompression,length(orders),typeof(orders)}(
+            orders, postprocessing, postprocessing_minimizes
+        )
     end
 end
 
@@ -122,7 +124,9 @@ function GreedyColoringAlgorithm(
     decompression::Symbol=:direct,
     postprocessing_minimizes::Symbol=:all_colors,
 )
-    return GreedyColoringAlgorithm{decompression}(order_or_orders; postprocessing, postprocessing_minimizes)
+    return GreedyColoringAlgorithm{decompression}(
+        order_or_orders; postprocessing, postprocessing_minimizes
+    )
 end
 
 ## Coloring
@@ -327,12 +331,18 @@ function _coloring(
     forced_colors::Union{AbstractVector{<:Integer},Nothing}=nothing,
 ) where {R}
     A_and_Aᵀ, edge_to_index = bidirectional_pattern(A; symmetric_pattern)
-    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A))
+    ag = AdjacencyGraph(
+        A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A)
+    )
     postprocessing_minimizes = algo.postprocessing_minimizes
     outputs_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
         _color, _star_set = star_coloring(
-            ag, vertices_in_order, algo.postprocessing; postprocessing_minimizes, forced_colors
+            ag,
+            vertices_in_order,
+            algo.postprocessing;
+            postprocessing_minimizes,
+            forced_colors,
         )
         (_row_color, _column_color, _symmetric_to_row, _symmetric_to_column) = remap_colors(
             eltype(ag), _color, maximum(_color), size(A)...
@@ -375,11 +385,15 @@ function _coloring(
     symmetric_pattern::Bool,
 ) where {R}
     A_and_Aᵀ, edge_to_index = bidirectional_pattern(A; symmetric_pattern)
-    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A))
+    ag = AdjacencyGraph(
+        A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A)
+    )
     postprocessing_minimizes = algo.postprocessing_minimizes
     outputs_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
-        _color, _tree_set = acyclic_coloring(ag, vertices_in_order, algo.postprocessing; postprocessing_minimizes)
+        _color, _tree_set = acyclic_coloring(
+            ag, vertices_in_order, algo.postprocessing; postprocessing_minimizes
+        )
         (_row_color, _column_color, _symmetric_to_row, _symmetric_to_column) = remap_colors(
             eltype(ag), _color, maximum(_color), size(A)...
         )

src/postprocessing.jl

@@ -28,10 +28,25 @@ function postprocess!(
 
     if star_or_tree_set isa StarSet
         # star_or_tree_set is a StarSet
-        postprocess_with_star_set!(bicoloring, g, row_color_used, column_color_used, color, star_or_tree_set, postprocessing_minimizes)
+        postprocess_with_star_set!(
+            bicoloring,
+            g,
+            row_color_used,
+            column_color_used,
+            color,
+            star_or_tree_set,
+            postprocessing_minimizes,
+        )
     else
         # star_or_tree_set is a TreeSet
-        postprocess_with_tree_set!(bicoloring, row_color_used, column_color_used, color, star_or_tree_set, postprocessing_minimizes)
+        postprocess_with_tree_set!(
+            bicoloring,
+            row_color_used,
+            column_color_used,
+            color,
+            star_or_tree_set,
+            postprocessing_minimizes,
+        )
     end
 
     if bicoloring
@@ -175,7 +190,8 @@ function postprocess_with_star_set!(
                                     #
                                     # Note that this heuristic also depends on the order in which
                                     # the trivial stars are processed, especially when there are ties in `color_counts`.
-                                    if row_color_counts[color[i]] > column_color_counts[color[j]]
+                                    if row_color_counts[color[i]] >
+                                        column_color_counts[color[j]]
                                         row_color_used[color[i]] = true
                                         hub[s] = i
                                     else
@@ -191,7 +207,9 @@ function postprocess_with_star_set!(
                                     hub[s] = i
                                     row_color_used[color[i]] = true
                                 else
-                                    error("The value postprocessing_minimizes = :$postprocessing_minimizes is not supported.")
+                                    error(
+                                        "The value postprocessing_minimizes = :$postprocessing_minimizes is not supported.",
+                                    )
                                 end
                             else
                                 # Previously processed trivial stars determined the hub vertex for this star
@@ -244,8 +262,8 @@ function postprocess_with_tree_set!(
             else
                 # It is not a star and both colors are needed during the decompression
                 (i, j) = reverse_bfs_orders[first]
-                v_col = min(i,j)
-                v_row = max(i,j)
+                v_col = min(i, j)
+                v_row = max(i, j)
                 row_color_used[color[v_row]] = true
                 column_color_used[color[v_col]] = true
             end
@@ -274,8 +292,8 @@ function postprocess_with_tree_set!(
             # Check if we have exactly one edge in the tree
             if ne_tree == 1
                 (i, j) = reverse_bfs_orders[first]
-                v_col = min(i,j)
-                v_row = max(i,j)
+                v_col = min(i, j)
+                v_row = max(i, j)
                 if column_color_used[color[v_col]]
                     # The vertex v_col is already an internal node in a non-trivial tree
                     reverse_bfs_orders[first] = (v_row, v_col)
@@ -307,7 +325,7 @@ function postprocess_with_tree_set!(
         # This is optimal because we never increase the number of colors in the target partition during this phase,
         # and all preceding steps of the post-processing are deterministic.
         if !all_trivial_trees_treated
-           for k in 1:nt
+            for k in 1:nt
                 # Position of the first edge in the tree
                 first = tree_edge_indices[k]
 
@@ -317,8 +335,8 @@ function postprocess_with_tree_set!(
                 # Check if we have exactly one edge in the tree
                 if ne_tree == 1
                     (i, j) = reverse_bfs_orders[first]
-                    v_col = min(i,j)
-                    v_row = max(i,j)
+                    v_col = min(i, j)
+                    v_row = max(i, j)
                     if !column_color_used[color[v_col]] && !row_color_used[color[v_row]]
                         if !bicoloring || postprocessing_minimizes == :all_colors
                             # Choose as root the vertex whose color is most frequent among the trivial trees.
@@ -330,7 +348,8 @@ function postprocess_with_tree_set!(
                             #
                             # Note that this heuristic also depends on the order in which
                             # the trivial trees are processed, especially when there are ties in `color_counts`.
-                            if row_color_counts[color[v_row]] > column_color_counts[color[v_col]]
+                            if row_color_counts[color[v_row]] >
+                                column_color_counts[color[v_col]]
                                 row_color_used[color[v_row]] = true
                                 reverse_bfs_orders[first] = (v_col, v_row)
                             else
@@ -346,7 +365,9 @@ function postprocess_with_tree_set!(
                             row_color_used[color[v_row]] = true
                             reverse_bfs_orders[first] = (v_col, v_row)
                         else
-                            error("The value postprocessing_minimizes = :$postprocessing_minimizes is not supported.")
+                            error(
+                                "The value postprocessing_minimizes = :$postprocessing_minimizes is not supported.",
+                            )
                         end
                     else
                         # Previously processed trivial trees determined the root vertex for this tree

test/random.jl

@@ -84,13 +84,22 @@ end;
             RandomOrder(StableRNG(0), 0); postprocessing=false, decompression=:direct
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:all_colors, decompression=:direct
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:all_colors,
+            decompression=:direct,
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:row_colors, decompression=:direct
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:row_colors,
+            decompression=:direct,
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:column_colors, decompression=:direct
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:column_colors,
+            decompression=:direct,
         ),
     )
         @testset "$((; m, n, p))" for (m, n, p) in asymmetric_params
@@ -111,13 +120,22 @@ end;
             RandomOrder(StableRNG(0), 0); postprocessing=false, decompression=:substitution
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:all_colors, decompression=:substitution
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:all_colors,
+            decompression=:substitution,
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:row_colors, decompression=:substitution
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:row_colors,
+            decompression=:substitution,
         ),
         GreedyColoringAlgorithm(
-            RandomOrder(StableRNG(0), 0); postprocessing=true, postprocessing_minimizes=:column_colors, decompression=:substitution
+            RandomOrder(StableRNG(0), 0);
+            postprocessing=true,
+            postprocessing_minimizes=:column_colors,
+            decompression=:substitution,
         ),
     )
         @testset "$((; m, n, p))" for (m, n, p) in asymmetric_params