Improve feasibility check

Author: gdalle

src/adtypes.jl

@@ -14,6 +14,7 @@ function coloring(
         elseif partition == :row
             forced_colors = ADTypes.row_coloring(A, algo)
         else
+            # TODO: improve once https://github.com/SciML/ADTypes.jl/issues/69 is done
             A_and_Aᵀ, _ = bidirectional_pattern(A; symmetric_pattern)
             forced_colors = ADTypes.symmetric_coloring(A_and_Aᵀ, algo)
         end

src/coloring.jl

@@ -1,3 +1,5 @@
+struct InvalidColoringError <: Exception end
+
 """
     partial_distance2_coloring(
         bg::BipartiteGraph, ::Val{side}, vertices_in_order::AbstractVector;
@@ -63,8 +65,11 @@ function partial_distance2_coloring!(
                 end
             end
         else
-            @assert forbidden_colors[forced_colors[v]] != v
-            color[v] = forced_colors[v]
+            if forbidden_colors[forced_colors[v]] == v
+                throw(InvalidColoringError())
+            else
+                color[v] = forced_colors[v]
+            end
         end
     end
 end
@@ -147,8 +152,11 @@ function star_coloring(
                 end
             end
         else
-            @assert forbidden_colors[forced_colors[v]] != v
-            color[v] = forced_colors[v]
+            if forbidden_colors[forced_colors[v]] == v
+                throw(InvalidColoringError())
+            else
+                color[v] = forced_colors[v]
+            end
         end
         _update_stars!(star, hub, g, v, color, first_neighbor)
     end
@@ -316,8 +324,11 @@ function acyclic_coloring(
                 end
             end
         else
-            @assert forbidden_colors[forced_colors[v]] != v
-            color[v] = forced_colors[v]
+            if forbidden_colors[forced_colors[v]] == v
+                throw(InvalidColoringError())
+            else
+                color[v] = forced_colors[v]
+            end
         end
         for (w, index_vw) in neighbors_with_edge_indices(g, v)  # grow two-colored stars around the vertex v
             !has_diagonal(g) || (v == w && continue)

src/constant.jl

@@ -4,20 +4,24 @@
 Coloring algorithm which always returns the same precomputed vector of colors.
 Useful when the optimal coloring of a matrix can be determined a priori due to its specific structure (e.g. banded).
 
-It is passed as an argument to the main function [`coloring`](@ref), but will only work if the associated `problem` has `:nonsymmetric` structure.
-Indeed, for symmetric coloring problems, we need more than just the vector of colors to allow fast decompression.
+It is passed as an argument to the main function [`coloring`](@ref), but will only work if the associated `problem` has a `:column` or `:row` partition.
 
 # Constructors
 
     ConstantColoringAlgorithm{partition}(matrix_template, color)
-    ConstantColoringAlgorithm(matrix_template, color; partition=:column)
+    ConstantColoringAlgorithm{partition,structure}(matrix_template, color)
+    ConstantColoringAlgorithm(
+        matrix_template, color;
+        structure=:nonsymmetric, partition=:column
+    )
 
 - `partition::Symbol`: either `:row` or `:column`.
+- `structure::Symbol`: either `:nonsymmetric` or `:symmetric`.
 - `matrix_template::AbstractMatrix`: matrix for which the vector of colors was precomputed (the algorithm will only accept matrices of the exact same size).
 - `color::Vector{<:Integer}`: vector of integer colors, one for each row or column (depending on `partition`).
 
 !!! warning
-    The second constructor (based on keyword arguments) is type-unstable.
+    The constructor based on keyword arguments is type-unstable if these arguments are not compile-time constants.
 
 We do not necessarily verify consistency between the matrix template and the vector of colors, this is the responsibility of the user.
 
@@ -63,40 +67,36 @@ julia> column_colors(result)
 
 - [`ADTypes.column_coloring`](@extref ADTypes.column_coloring)
 - [`ADTypes.row_coloring`](@extref ADTypes.row_coloring)
+- [`ADTypes.symmetric_coloring`](@extref ADTypes.symmetric_coloring)
 """
-struct ConstantColoringAlgorithm{
-    partition,
-    M<:AbstractMatrix,
-    T<:Integer,
-    R<:AbstractColoringResult{:nonsymmetric,partition,:direct},
-} <: ADTypes.AbstractColoringAlgorithm
+struct ConstantColoringAlgorithm{partition,structure,M<:AbstractMatrix,T<:Integer} <:
+       ADTypes.AbstractColoringAlgorithm
     matrix_template::M
     color::Vector{T}
-    result::R
-end
 
-function ConstantColoringAlgorithm{:column}(
-    matrix_template::AbstractMatrix, color::Vector{<:Integer}
-)
-    bg = BipartiteGraph(matrix_template)
-    result = ColumnColoringResult(matrix_template, bg, color)
-    T, M, R = eltype(bg), typeof(matrix_template), typeof(result)
-    return ConstantColoringAlgorithm{:column,M,T,R}(matrix_template, color, result)
+    function ConstantColoringAlgorithm{partition,structure}(
+        matrix_template::AbstractMatrix, color::Vector{<:Integer}
+    ) where {partition,structure}
+        check_valid_problem(structure, partition)
+        return new{partition,structure,typeof(matrix_template),eltype(color)}(
+            matrix_template, color
+        )
+    end
 end
 
-function ConstantColoringAlgorithm{:row}(
+function ConstantColoringAlgorithm{partition}(
     matrix_template::AbstractMatrix, color::Vector{<:Integer}
-)
-    bg = BipartiteGraph(matrix_template)
-    result = RowColoringResult(matrix_template, bg, color)
-    T, M, R = eltype(bg), typeof(matrix_template), typeof(result)
-    return ConstantColoringAlgorithm{:row,M,T,R}(matrix_template, color, result)
+) where {partition}
+    return ConstantColoringAlgorithm{partition,:nonsymmetric}(matrix_template, color)
 end
 
 function ConstantColoringAlgorithm(
-    matrix_template::AbstractMatrix, color::Vector{<:Integer}; partition::Symbol=:column
+    matrix_template::AbstractMatrix,
+    color::Vector{<:Integer};
+    structure::Symbol=:nonsymmetric,
+    partition::Symbol=:column,
 )
-    return ConstantColoringAlgorithm{partition}(matrix_template, color)
+    return ConstantColoringAlgorithm{partition,structure}(matrix_template, color)
 end
 
 function check_template(algo::ConstantColoringAlgorithm, A::AbstractMatrix)
@@ -110,25 +110,25 @@ function check_template(algo::ConstantColoringAlgorithm, A::AbstractMatrix)
     end
 end
 
-function coloring(
-    A::AbstractMatrix,
-    ::ColoringProblem{:nonsymmetric,partition},
-    algo::ConstantColoringAlgorithm{partition};
-    decompression_eltype::Type=Float64,
-    symmetric_pattern::Bool=false,
-) where {partition}
+function ADTypes.column_coloring(
+    A::AbstractMatrix, algo::ConstantColoringAlgorithm{:column,:nonsymmetric}
+)
     check_template(algo, A)
-    return algo.result
+    return algo.color
 end
 
-function ADTypes.column_coloring(
-    A::AbstractMatrix, algo::ConstantColoringAlgorithm{:column}
+function ADTypes.row_coloring(
+    A::AbstractMatrix, algo::ConstantColoringAlgorithm{:row,:nonsymmetric}
 )
     check_template(algo, A)
-    return column_colors(algo.result)
+    return algo.color
 end
 
-function ADTypes.row_coloring(A::AbstractMatrix, algo::ConstantColoringAlgorithm{:row})
+function ADTypes.symmetric_coloring(
+    A::AbstractMatrix, algo::ConstantColoringAlgorithm{:column,:symmetric}
+)
     check_template(algo, A)
-    return row_colors(algo.result)
+    return algo.color
 end
+
+# TODO: handle bidirectional once https://github.com/SciML/ADTypes.jl/issues/69 is done

test/constant.jl

@@ -1,16 +1,20 @@
 using ADTypes: ADTypes
 using SparseMatrixColorings
+using SparseMatrixColorings: InvalidColoringError
 using Test
 
-matrix_template = ones(100, 200)
+matrix_template = ones(Bool, 10, 20)
+sym_matrix_template = ones(Bool, 10, 10)
 
 @testset "Column coloring" begin
     problem = ColoringProblem(; structure=:nonsymmetric, partition=:column)
-    color = rand(1:5, size(matrix_template, 2))
+    color = collect(1:20)
     algo = ConstantColoringAlgorithm(matrix_template, color; partition=:column)
-    wrong_algo = ConstantColoringAlgorithm(matrix_template, color; partition=:row)
+    wrong_algo = ConstantColoringAlgorithm{:row}(matrix_template, color)
+    wrong_color = ConstantColoringAlgorithm{:column}(matrix_template, ones(Int, 20))
     @test_throws DimensionMismatch coloring(transpose(matrix_template), problem, algo)
     @test_throws MethodError coloring(matrix_template, problem, wrong_algo)
+    @test_throws InvalidColoringError coloring(matrix_template, problem, wrong_color)
     result = coloring(matrix_template, problem, algo)
     @test column_colors(result) == color
     @test ADTypes.column_coloring(matrix_template, algo) == color
@@ -19,11 +23,36 @@ end
 
 @testset "Row coloring" begin
     problem = ColoringProblem(; structure=:nonsymmetric, partition=:row)
-    color = rand(1:5, size(matrix_template, 1))
+    color = collect(1:10)
     algo = ConstantColoringAlgorithm(matrix_template, color; partition=:row)
+    wrong_algo = ConstantColoringAlgorithm{:column}(matrix_template, color)
+    wrong_color = ConstantColoringAlgorithm{:row}(matrix_template, ones(Int, 10))
     @test_throws DimensionMismatch coloring(transpose(matrix_template), problem, algo)
+    @test_throws MethodError coloring(matrix_template, problem, wrong_algo)
+    @test_throws InvalidColoringError coloring(matrix_template, problem, wrong_color)
     result = coloring(matrix_template, problem, algo)
     @test row_colors(result) == color
     @test ADTypes.row_coloring(matrix_template, algo) == color
     @test_throws MethodError ADTypes.column_coloring(matrix_template, algo)
 end
+
+@testset "Symmetric coloring" begin
+    problem = ColoringProblem(; structure=:symmetric, partition=:column)
+    color = collect(1:10)
+    algo = ConstantColoringAlgorithm(
+        sym_matrix_template, color; partition=:column, structure=:symmetric
+    )
+    wrong_algo = ConstantColoringAlgorithm{:column,:nonsymmetric}(
+        sym_matrix_template, color
+    )
+    wrong_color = ConstantColoringAlgorithm{:column,:symmetric}(
+        sym_matrix_template, ones(Int, 20)
+    )
+    @test_throws DimensionMismatch coloring(matrix_template, problem, algo)
+    @test_throws MethodError coloring(sym_matrix_template, problem, wrong_algo)
+    @test_throws InvalidColoringError coloring(sym_matrix_template, problem, wrong_color)
+    result = coloring(sym_matrix_template, problem, algo)
+    @test column_colors(result) == color
+    @test ADTypes.symmetric_coloring(sym_matrix_template, algo) == color
+    @test_throws MethodError ADTypes.column_coloring(sym_matrix_template, algo)
+end