Fix tests

Author: gdalle

ext/SparseMatrixColoringsJuMPExt.jl

@@ -1,20 +1,26 @@
 module SparseMatrixColoringsJuMPExt
 
 using ADTypes: ADTypes
-using JuMP
-using LinearAlgebra
+using JuMP:
+    Model,
+    assert_is_solved_and_feasible,
+    optimize!,
+    set_silent,
+    value,
+    @variable,
+    @constraint,
+    @objective
 import MathOptInterface as MOI
-using SparseArrays
 using SparseMatrixColorings:
     BipartiteGraph, OptimalColoringAlgorithm, nb_vertices, neighbors, pattern, vertices
 
 function optimal_distance2_coloring(
-    bg::BipartiteGraph, ::Val{side}, optimizer::Type{O}
-) where {side,O<:MOI.AbstractOptimizer}
+    bg::BipartiteGraph, ::Val{side}, optimizer::O; silent::Bool=true
+) where {side,O}
     other_side = 3 - side
     n = nb_vertices(bg, Val(side))
     model = Model(optimizer)
-    set_silent(model)
+    silent && set_silent(model)
     @variable(model, 1 <= color[i=1:n] <= i, Int)
     @variable(model, ncolors, Int)
     @constraint(model, [ncolors; color] in MOI.CountDistinct(n + 1))
@@ -25,17 +31,27 @@ function optimal_distance2_coloring(
     @objective(model, Min, ncolors)
     optimize!(model)
     assert_is_solved_and_feasible(model)
-    return round.(Int, value.(color))
+    color_int = round.(Int, value.(color))
+    # remap to 1:cmax
+    true_ncolors = 0
+    remap = fill(0, maximum(color_int))
+    for c in color_int
+        if remap[c] == 0
+            true_ncolors += 1
+            remap[c] = true_ncolors
+        end
+    end
+    return remap[color_int]
 end
 
 function ADTypes.column_coloring(A::AbstractMatrix, algo::OptimalColoringAlgorithm)
     bg = BipartiteGraph(A)
-    return optimal_distance2_coloring(bg, Val(2), algo.optimizer)
+    return optimal_distance2_coloring(bg, Val(2), algo.optimizer; algo.silent)
 end
 
 function ADTypes.row_coloring(A::AbstractMatrix, algo::OptimalColoringAlgorithm)
     bg = BipartiteGraph(A)
-    return optimal_distance2_coloring(bg, Val(1), algo.optimizer)
+    return optimal_distance2_coloring(bg, Val(1), algo.optimizer; algo.silent)
 end
 
 end

src/optimal.jl

@@ -6,13 +6,22 @@ Coloring algorithm that relies on mathematical programming with [JuMP](https://j
 !!! warning
     This algorithm is only available when JuMP is loaded. If you encounter a method error, run `import JuMP` in your REPL and try again.
 
+!!! danger
+    The coloring problem is NP-hard, so it is unreasonable to expect an optimal solution in reasonable time for large instances.
+
 # Constructor
 
-    OptimalColoringAlgorithm(optimizer)
+    OptimalColoringAlgorithm(optimizer; silent::Bool=true)
 
-The `optimizer` argument can be any JuMP-compatible optimizer, like `HiGHS.Optimizer`.
+The `optimizer` argument can be any JuMP-compatible optimizer.
+However, the problem formulation is best suited to CP-SAT optimizers like [MiniZinc](https://github.com/jump-dev/MiniZinc.jl).
 You can use [`optimizer_with_attributes`](https://jump.dev/JuMP.jl/stable/api/JuMP/#optimizer_with_attributes) to set solver-specific parameters.
 """
-struct OptimalColoringAlgorithm{S} <: ADTypes.AbstractColoringAlgorithm
-    optimizer::S
+struct OptimalColoringAlgorithm{O} <: ADTypes.AbstractColoringAlgorithm
+    optimizer::O
+    silent::Bool
+end
+
+function OptimalColoringAlgorithm(optimizer; silent::Bool=true)
+    return OptimalColoringAlgorithm(optimizer, silent)
 end

test/Project.toml

@@ -18,6 +18,7 @@ JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MatrixDepot = "b51810bb-c9f3-55da-ae3c-350fc1fbce05"
+MiniZinc = "a7f392d2-6c35-496e-b8cc-0974fbfcbf91"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35"

test/optimal.jl

@@ -2,20 +2,20 @@ using SparseArrays
 using SparseMatrixColorings
 using StableRNGs
 using Test
+using JuMP
+using MiniZinc
 
 rng = StableRNG(0)
 
 asymmetric_params = vcat(
-    [(10, 20, p) for p in (0.0:0.1:0.5)],
-    [(20, 10, p) for p in (0.0: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)],
+    [(10, 20, p) for p in (0.0:0.1:0.5)], [(20, 10, p) for p in (0.0:0.1:0.5)]
 )
 
+algo = GreedyColoringAlgorithm()
+optalgo = OptimalColoringAlgorithm(() -> MiniZinc.Optimizer{Float64}("highs"); silent=false)
+
 @testset "Column coloring" begin
     problem = ColoringProblem(; structure=:nonsymmetric, partition=:column)
-    algo = GreedyColoringAlgorithm()
-    optalgo = OptimalColoringAlgorithm(HiGHS.Optimizer)
     for (m, n, p) in asymmetric_params
         A = sprand(rng, m, n, p)
         result = coloring(A, problem, algo)
@@ -26,8 +26,6 @@ end
 
 @testset "Row coloring" begin
     problem = ColoringProblem(; structure=:nonsymmetric, partition=:row)
-    algo = GreedyColoringAlgorithm()
-    optalgo = OptimalColoringAlgorithm(HiGHS.Optimizer)
     for (m, n, p) in asymmetric_params
         A = sprand(rng, m, n, p)
         result = coloring(A, problem, algo)