Single type

Author: gdalle

src/adtypes.jl

@@ -5,7 +5,7 @@ function coloring(
     kwargs...,
 )
     bg = BipartiteGraph(A)
-    color = convert(Vector{Int}, ADTypes.column_coloring(A, algo))
+    color = convert(Vector{eltype(bg)}, ADTypes.column_coloring(A, algo))
     return ColumnColoringResult(A, bg, color)
 end
 
@@ -16,6 +16,6 @@ function coloring(
     kwargs...,
 )
     bg = BipartiteGraph(A)
-    color = convert(Vector{Int}, ADTypes.row_coloring(A, algo))
+    color = convert(Vector{eltype(bg)}, ADTypes.row_coloring(A, algo))
     return RowColoringResult(A, bg, color)
 end

src/coloring.jl

@@ -87,7 +87,7 @@ function star_coloring(
     first_neighbor = fill((zero(T), zero(T), zero(T)), nv)  # at first no neighbors have been encountered
     treated = zeros(T, nv)
     star = Vector{T}(undef, ne)
-    hub = Int[]  # one hub for each star, including the trivial ones
+    hub = T[]  # one hub for each star, including the trivial ones
     vertices_in_order = vertices(g, order)
 
     for v in vertices_in_order

src/constant.jl

@@ -65,7 +65,10 @@ julia> column_colors(result)
 - [`ADTypes.row_coloring`](@extref ADTypes.row_coloring)
 """
 struct ConstantColoringAlgorithm{
-    partition,M<:AbstractMatrix,T,R<:AbstractColoringResult{:nonsymmetric,partition,:direct}
+    partition,
+    M<:AbstractMatrix,
+    T<:Integer,
+    R<:AbstractColoringResult{:nonsymmetric,partition,:direct},
 } <: ADTypes.AbstractColoringAlgorithm
     matrix_template::M
     color::Vector{T}
@@ -77,7 +80,7 @@ function ConstantColoringAlgorithm{:column}(
 )
     bg = BipartiteGraph(matrix_template)
     result = ColumnColoringResult(matrix_template, bg, color)
-    T, M, R = eltype(color), typeof(matrix_template), typeof(result)
+    T, M, R = eltype(bg), typeof(matrix_template), typeof(result)
     return ConstantColoringAlgorithm{:column,M,T,R}(matrix_template, color, result)
 end
 
@@ -86,7 +89,7 @@ function ConstantColoringAlgorithm{:row}(
 )
     bg = BipartiteGraph(matrix_template)
     result = RowColoringResult(matrix_template, bg, color)
-    T, M, R = eltype(color), typeof(matrix_template), typeof(result)
+    T, M, R = eltype(bg), typeof(matrix_template), typeof(result)
     return ConstantColoringAlgorithm{:row,M,T,R}(matrix_template, color, result)
 end
 

src/decompression.jl

@@ -677,12 +677,12 @@ function decompress!(
     result::LinearSystemColoringResult,
     uplo::Symbol=:F,
 )
-    (; color, strict_upper_nonzero_inds, T_factorization, strict_upper_nonzeros_A) = result
+    (; color, strict_upper_nonzero_inds, M_factorization, strict_upper_nonzeros_A) = result
     S = result.ag.S
     uplo == :F && check_same_pattern(A, S)
 
     # TODO: for some reason I cannot use ldiv! with a sparse QR
-    strict_upper_nonzeros_A = T_factorization \ vec(B)
+    strict_upper_nonzeros_A = M_factorization \ vec(B)
     fill!(A, zero(eltype(A)))
     for i in axes(A, 1)
         if !iszero(S[i, i])

src/graph.jl

@@ -23,6 +23,7 @@ end
 
 SparsityPatternCSC(A::SparseMatrixCSC) = SparsityPatternCSC(A.m, A.n, A.colptr, A.rowval)
 
+Base.eltype(::SparsityPatternCSC{Ti}) where {Ti} = Ti
 Base.size(S::SparsityPatternCSC) = (S.m, S.n)
 Base.size(S::SparsityPatternCSC, d::Integer) = d::Integer <= 2 ? size(S)[d] : 1
 Base.axes(S::SparsityPatternCSC, d::Integer) = Base.OneTo(size(S, d))
@@ -227,6 +228,8 @@ struct AdjacencyGraph{T<:Integer,has_diagonal}
     edge_to_index::Vector{T}
 end
 
+Base.eltype(::AdjacencyGraph{T}) where {T} = T
+
 function AdjacencyGraph(
     S::SparsityPatternCSC{T},
     edge_to_index::Vector{T}=build_edge_to_index(S);
@@ -343,6 +346,8 @@ struct BipartiteGraph{T<:Integer}
     S2::SparsityPatternCSC{T}
 end
 
+Base.eltype(::BipartiteGraph{T}) where {T} = T
+
 function BipartiteGraph(A::AbstractMatrix; symmetric_pattern::Bool=false)
     return BipartiteGraph(SparseMatrixCSC(A); symmetric_pattern)
 end