Add tests

Author: gdalle

src/order.jl

@@ -146,9 +146,8 @@ function DegreeBuckets(::Type{T}, degrees::Vector{T}, dmax::Integer) where {T}
     # bucket limits
     bucket_high = accumulate(+, deg_count)
     bucket_low = similar(bucket_high)
-    bucket_low[1] = 0
-    bucket_low[2:end] .= bucket_high[1:(end - 1)]
-    bucket_low .+= 1
+    bucket_low[1] = 1
+    bucket_low[2:end] .= @view(bucket_high[1:(end - 1)]) .+ 1
     # assign each vertex to the correct position inside its degree class
     bucket_storage = similar(degrees, T)
     positions = similar(degrees, T)
@@ -380,3 +379,14 @@ The `elimination_algorithm` must be an instance of `CliqueTrees.EliminationAlgor
 struct PerfectEliminationOrder{E} <: AbstractOrder
     elimination_algorithm::E
 end
+
+function all_orders()
+    return [
+        NaturalOrder(),
+        RandomOrder(),
+        LargestFirst(),
+        SmallestLast(),
+        IncidenceDegree(),
+        DynamicLargestFirst(),
+    ]
+end

test/allocations.jl

@@ -132,3 +132,33 @@ end
         test_noallocs_structured_decompression(1000; structure, partition, decompression)
     end
 end
+
+@testset "Single precision" begin
+    n, p = 10_000, 0.001
+    A64 = sparse(Symmetric(sprand(rng, Float32, 100, 100, 0.1)))
+    A32 = convert(SparseMatrixCSC{Float32,Int32}, A64)
+    @testset "$structure - $partition - $decompression" for (
+        structure, partition, decompression
+    ) in [
+        (:nonsymmetric, :column, :direct),
+        (:nonsymmetric, :row, :direct),
+        (:symmetric, :column, :direct),
+        (:symmetric, :column, :substitution),
+        (:nonsymmetric, :bidirectional, :direct),
+        (:nonsymmetric, :bidirectional, :substitution),
+    ]
+        @testset for order in
+                     (NaturalOrder(), RandomOrder(), LargestFirst(), DynamicLargestFirst())
+            problem = ColoringProblem(; structure, partition)
+            algo = GreedyColoringAlgorithm(order; decompression)
+            b64 = @b fast_coloring(A64, problem, algo)
+            b32 = @b fast_coloring(A32, problem, algo)
+            # check that we allocate no more than 50% + epsilon with Int32
+            if decompression == :direct
+                @test b32.bytes < 0.6 * b64.bytes
+            else
+                @test_broken b32.bytes < 0.6 * b64.bytes
+            end
+        end
+    end
+end;

test/type_stability.jl

@@ -3,7 +3,7 @@ using JET
 using LinearAlgebra
 using SparseArrays
 using SparseMatrixColorings
-using SparseMatrixColorings: matrix_versions, respectful_similar
+using SparseMatrixColorings: matrix_versions, respectful_similar, all_orders
 using StableRNGs
 using Test
 
@@ -178,7 +178,7 @@ end;
         (:nonsymmetric, :bidirectional, :direct),
         (:nonsymmetric, :bidirectional, :substitution),
     ]
-        for order in (NaturalOrder(), RandomOrder(), LargestFirst(), DynamicLargestFirst())
+        @testset for order in all_orders()
             result = coloring(
                 A,
                 ColoringProblem(; structure, partition),