More robust tests (#12)

Author: gdalle

README.md

@@ -13,7 +13,7 @@ Coloring algorithms for sparse Jacobian and Hessian matrices.
 To install this package, run the following in a Julia Pkg REPL:
 
 ```julia
-pkg> add https://github.com/gdalle/SparseMatrixColorings.jl
+pkg> add SparseMatrixColorings
 ```
 
 ## Background

src/coloring.jl

@@ -75,7 +75,7 @@ function star_coloring(g::Graph, order::AbstractOrder)
     # Initialize data structures
     color = zeros(Int, length(g))
     forbidden_colors = zeros(Int, length(g))
-    first_neighbor = Vector{Tuple{Int,Int}}(undef, length(g))
+    first_neighbor = fill((0, 0), length(g))  # at first no neighbors have been encountered
     treated = zeros(Int, length(g))
     star = Dict{Tuple{Int,Int},Int}()
     hub = Int[]
@@ -137,13 +137,13 @@ end
 
 function _update_stars!(
     # modified
-    star,
+    star::Dict{<:Tuple,<:Integer},
     hub::AbstractVector{<:Integer},
     # not modified
     g::Graph,
     v::Integer,
     color::AbstractVector{<:Integer},
-    first_neighbor::AbstractVector{<:Tuple{<:Integer,<:Integer}},
+    first_neighbor::AbstractVector{<:Tuple},
 )
     for w in neighbors(g, v)
         iszero(color[w]) && continue

src/matrices.jl

@@ -12,17 +12,17 @@ Used for internal testing.
 """
 function matrix_versions(A)
     A_dense = Matrix(A)
-    A_sparse = SparseMatrixCSC(A)
+    A_sparse = sparse(A)
     versions = [
         A_dense,
         transpose(Matrix(transpose(A_dense))),
         adjoint(Matrix(adjoint(A_dense))),
         A_sparse,
-        transpose(SparseMatrixCSC(transpose(A_sparse))),
-        adjoint(SparseMatrixCSC(adjoint(A_sparse))),
+        transpose(sparse(transpose(A_sparse))),
+        adjoint(sparse(adjoint(A_sparse))),
     ]
     if issymmetric(A)
-        append!(versions, [Symmetric(A_dense), Symmetric(A_sparse)])
+        append!(versions, Symmetric.(versions))
     end
     return versions
 end

test/coloring_correctness.jl

@@ -15,40 +15,42 @@ algo = GreedyColoringAlgorithm()
 
 @test startswith(string(algo), "GreedyColoringAlgorithm(")
 
+asymmetric_params = vcat(
+    [(10, 20, p) for p in (0.1:0.1:0.5)],
+    [(20, 10, p) for p in (0.1:0.1:0.5)],
+    [(100, 200, p) for p in (0.01:0.01:0.05)],
+    [(200, 100, p) for p in (0.01:0.01:0.05)],
+)
+
+symmetric_params = vcat(
+    [(10, p) for p in (0.1:0.05:0.5)], #
+    [(100, p) for p in (0.01:0.005:0.05)],
+)
+
 @testset "Column coloring" begin
-    @testset "Size ($m, $n) - sparsity $p" for (m, n, p) in [
-        (10, 20, 0.05), (20, 10, 0.05), (100, 200, 0.05), (200, 100, 0.05)
-    ]
+    @testset "Size ($m, $n) - sparsity $p" for (m, n, p) in asymmetric_params
         @testset "$(typeof(A))" for A in matrix_versions(sprand(rng, Bool, m, n, p))
             column_color = column_coloring(A, algo)
             @test check_structurally_orthogonal_columns(A, column_color)
-            @test minimum(column_color) == 1
-            @test maximum(column_color) < size(A, 2) ÷ 2
         end
     end
 end;
 
 @testset "Row coloring" begin
-    @testset "Size ($m, $n) - sparsity $p" for (m, n, p) in [
-        (10, 20, 0.05), (20, 10, 0.05), (100, 200, 0.05), (200, 100, 0.05)
-    ]
-        @testset "$(typeof(A))" for A in matrix_versions(sprand(rng, Bool, m, n, 0.05))
+    @testset "Size ($m, $n) - sparsity $p" for (m, n, p) in asymmetric_params
+        @testset "$(typeof(A))" for A in matrix_versions(sprand(rng, Bool, m, n, p))
             row_color = row_coloring(A, algo)
             @test check_structurally_orthogonal_columns(transpose(A), row_color)
-            @test minimum(row_color) == 1
-            @test maximum(row_color) < size(A, 1) ÷ 2
         end
     end
 end;
 
 @testset "Symmetric coloring" begin
-    @testset "Size ($n, $n) - sparsity $p" for (n, p) in [(10, 0.05), (100, 0.05)]
+    @testset "Size ($n, $n) - sparsity $p" for (n, p) in symmetric_params
         @testset "$(typeof(A))" for A in
                                     matrix_versions(Symmetric(sprand(rng, Bool, n, n, p)))
             symmetric_color = symmetric_coloring(A, algo)
             @test check_symmetrically_orthogonal_columns(A, symmetric_color)
-            @test minimum(symmetric_color) == 1
-            @test maximum(symmetric_color) < size(A, 2) ÷ 2
         end
     end
 end;