Move coloring soundness tests to DIT (#246)

Author: gdalle

DifferentiationInterface/src/sparse/coloring.jl

@@ -89,36 +89,6 @@ function distance2_row_coloring(g::BipartiteGraph)
     return colors
 end
 
-function check_structurally_orthogonal_columns(
-    A::AbstractMatrix, colors::AbstractVector{<:Integer}
-)
-    for c in unique(colors)
-        js = filter(j -> colors[j] == c, axes(A, 2))
-        Ajs = @view A[:, js]
-        nonzeros_per_row = count(!iszero, Ajs; dims=2)
-        if maximum(nonzeros_per_row) > 1
-            @warn "Color $c has columns $js sharing nonzeros"
-            return false
-        end
-    end
-    return true
-end
-
-function check_structurally_orthogonal_rows(
-    A::AbstractMatrix, colors::AbstractVector{<:Integer}
-)
-    for c in unique(colors)
-        is = filter(i -> colors[i] == c, axes(A, 1))
-        Ais = @view A[is, :]
-        nonzeros_per_column = count(!iszero, Ais; dims=1)
-        if maximum(nonzeros_per_column) > 1
-            @warn "Color $c has rows $is sharing nonzeros"
-            return false
-        end
-    end
-    return true
-end
-
 ## Hessian coloring
 
 """
@@ -189,30 +159,6 @@ function star_coloring(g::AdjacencyGraph)
     return colors
 end
 
-function check_symmetrically_structurally_orthogonal(
-    A::AbstractMatrix, colors::AbstractVector{<:Integer}
-)
-    for i in axes(A, 2), j in axes(A, 2)
-        if !iszero(A[i, j])
-            group_i = filter(i2 -> (i2 != i) && (colors[i2] == colors[i]), axes(A, 2))
-            group_j = filter(j2 -> (j2 != j) && (colors[j2] == colors[j]), axes(A, 2))
-            A_group_i_column_j = @view A[group_i, j]
-            A_group_j_column_i = @view A[group_j, i]
-            nonzeros_group_i_column_j = count(!iszero, A_group_i_column_j)
-            nonzeros_group_j_column_i = count(!iszero, A_group_j_column_i)
-            if nonzeros_group_i_column_j > 0 && nonzeros_group_j_column_i > 0
-                @warn """
-                For coefficient $((i, j)), both of the following have confounding zeros:
-                - color $(colors[j]) with group $group_j
-                - color $(colors[i]) with group $group_i
-                """
-                return false
-            end
-        end
-    end
-    return true
-end
-
 ## ADTypes overloads
 
 """

DifferentiationInterface/test/Internals/coloring.jl

@@ -1,5 +1,6 @@
 using ADTypes: ADTypes
 import DifferentiationInterface as DI
+import DifferentiationInterfaceTest as DIT
 using LinearAlgebra: I, Symmetric
 using SparseArrays: sprand
 
@@ -8,14 +9,14 @@ alg = DI.GreedyColoringAlgorithm()
 A = sprand(Bool, 100, 200, 0.05)
 
 column_colors = ADTypes.column_coloring(A, alg)
-@test DI.check_structurally_orthogonal_columns(A, column_colors)
+@test DIT.check_structurally_orthogonal_columns(A, column_colors)
 @test maximum(column_colors) < size(A, 2) ÷ 2
 
 row_colors = ADTypes.row_coloring(A, alg)
-@test DI.check_structurally_orthogonal_rows(A, row_colors)
+@test DIT.check_structurally_orthogonal_rows(A, row_colors)
 @test maximum(row_colors) < size(A, 1) ÷ 2
 
 S = Symmetric(sprand(Bool, 100, 100, 0.05)) + I
 symmetric_colors = ADTypes.symmetric_coloring(S, alg)
-@test DI.check_symmetrically_structurally_orthogonal(S, symmetric_colors)
+@test DIT.check_symmetrically_structurally_orthogonal(S, symmetric_colors)
 @test maximum(symmetric_colors) < size(A, 2) ÷ 2

DifferentiationInterfaceTest/src/DifferentiationInterfaceTest.jl

@@ -61,6 +61,7 @@ include("utils/zero_backends.jl")
 include("utils/misc.jl")
 include("utils/filter.jl")
 
+include("tests/coloring.jl")
 include("tests/correctness.jl")
 include("tests/type_stability.jl")
 include("tests/sparsity.jl")

DifferentiationInterfaceTest/src/tests/coloring.jl

@@ -0,0 +1,53 @@
+function check_structurally_orthogonal_columns(
+    A::AbstractMatrix, colors::AbstractVector{<:Integer}
+)
+    for c in unique(colors)
+        js = filter(j -> colors[j] == c, axes(A, 2))
+        Ajs = @view A[:, js]
+        nonzeros_per_row = count(!iszero, Ajs; dims=2)
+        if maximum(nonzeros_per_row) > 1
+            @warn "Color $c has columns $js sharing nonzeros"
+            return false
+        end
+    end
+    return true
+end
+
+function check_structurally_orthogonal_rows(
+    A::AbstractMatrix, colors::AbstractVector{<:Integer}
+)
+    for c in unique(colors)
+        is = filter(i -> colors[i] == c, axes(A, 1))
+        Ais = @view A[is, :]
+        nonzeros_per_column = count(!iszero, Ais; dims=1)
+        if maximum(nonzeros_per_column) > 1
+            @warn "Color $c has rows $is sharing nonzeros"
+            return false
+        end
+    end
+    return true
+end
+
+function check_symmetrically_structurally_orthogonal(
+    A::AbstractMatrix, colors::AbstractVector{<:Integer}
+)
+    for i in axes(A, 2), j in axes(A, 2)
+        if !iszero(A[i, j])
+            group_i = filter(i2 -> (i2 != i) && (colors[i2] == colors[i]), axes(A, 2))
+            group_j = filter(j2 -> (j2 != j) && (colors[j2] == colors[j]), axes(A, 2))
+            A_group_i_column_j = @view A[group_i, j]
+            A_group_j_column_i = @view A[group_j, i]
+            nonzeros_group_i_column_j = count(!iszero, A_group_i_column_j)
+            nonzeros_group_j_column_i = count(!iszero, A_group_j_column_i)
+            if nonzeros_group_i_column_j > 0 && nonzeros_group_j_column_i > 0
+                @warn """
+                For coefficient $((i, j)), both of the following have confounding zeros:
+                - color $(colors[j]) with group $group_j
+                - color $(colors[i]) with group $group_i
+                """
+                return false
+            end
+        end
+    end
+    return true
+end

DifferentiationInterfaceTest/test/coloring.jl

@@ -0,0 +1,22 @@
+using ADTypes: ADTypes
+import DifferentiationInterface as DI
+import DifferentiationInterfaceTest as DIT
+using LinearAlgebra: I, Symmetric
+using SparseArrays: sprand
+
+alg = DI.GreedyColoringAlgorithm()
+
+A = sprand(Bool, 100, 200, 0.05)
+
+column_colors = ADTypes.column_coloring(A, alg)
+@test DIT.check_structurally_orthogonal_columns(A, column_colors)
+@test maximum(column_colors) < size(A, 2) ÷ 2
+
+row_colors = ADTypes.row_coloring(A, alg)
+@test DIT.check_structurally_orthogonal_rows(A, row_colors)
+@test maximum(row_colors) < size(A, 1) ÷ 2
+
+S = Symmetric(sprand(Bool, 100, 100, 0.05)) + I
+symmetric_colors = ADTypes.symmetric_coloring(S, alg)
+@test DIT.check_symmetrically_structurally_orthogonal(S, symmetric_colors)
+@test maximum(symmetric_colors) < size(A, 2) ÷ 2