fix failed conversion from GBMatrix{Int} to GBMatrix{Float32} #97

Author: rayegun

src/abstractgbarray.jl

@@ -67,6 +67,7 @@ Base.eltype(::AbstractGBArray{T, F}) where {T, F} = Union{T, F}
 Base.eltype(::Type{<:AbstractGBArray{T, F}}) where{T, F} = Union{T, F}
 
 storedeltype(x) = eltype(x)
+storedeltype(::Type{<:AbstractGBArray{T}}) where T = T
 storedeltype(::AbstractGBArray{T}) where T = T
 
 Base.unsafe_convert(::Type{LibGraphBLAS.GrB_Matrix}, A::AbstractGBArray) = A.p[]

src/convert.jl

@@ -1,38 +1,37 @@
 # First we'll just support element type conversions.
 # This is crucial since we can't pass DataTypes to UDF handlers.
 
-# pass through for most cases
-conform(M::AbstractGBArray) = M
-
-function Base.convert(::Type{M}, A::N; fill::F = getfill(A)) where {F, M<:AbstractGBArray, N<:AbstractGBArray}
-    !(F <: Union{Nothing, Missing}) && (fill = convert(eltype(M), fill))
-    isabstracttype(M) && throw(ArgumentError("$M is an abstract type, which cannot be constructed."))
+function applyjl!(F, C::AbstractGBArray, A::AbstractGBArray)
+    isabstracttype(F) && throw(ArgumentError("$M is an abstract type, which cannot be constructed."))
     x = tempunpack!(A)
     repack! = x[end]
     values = x[end - 1]
     indices = x[begin:end-2]
-    newvalues = unsafe_wrap(Array, _sizedjlmalloc(length(values), eltype(M)), size(values))
-    copyto!(newvalues, values)
+    newvalues = unsafe_wrap(Array, _sizedjlmalloc(length(values), storedeltype(C)), size(values))
+    map!(F, newvalues, values)
     newindices = _copytoraw.(indices)
     repack!()
+    unsafepack!(C, newindices..., newvalues, false; decrementindices = false, order = storageorder(A))
+    return C
+end
+
+function Base.convert(::Type{M}, A::N; fill::F = getfill(A)) where {F, M<:AbstractGBArray, N<:AbstractGBArray}
+    !(F <: Union{Nothing, Missing}) && (fill = convert(storedeltype(M), fill))
     B = M(size(A, 1), size(A, 2); fill)
-    unsafepack!(B, newindices..., newvalues, false; decrementindices = false, order = storageorder(A))
+    applyjl!(storedeltype(B), B, A)
+end
+function Base.convert(::Type{M}, A::N; fill::F = getfill(A)) where {F, M<:AbstractGBVector, N<:AbstractGBVector}
+    !(F <: Union{Nothing, Missing}) && (fill = convert(eltype(M), fill))
+    B = M(size(A, 1); fill)
+    applyjl!(storedeltype(B), B, A)
 end
 
 Base.convert(::Type{M}, A::M; fill = nothing) where {M<:AbstractGBArray} = A
 
 function LinearAlgebra.copy_oftype(A::GBArrayOrTranspose, ::Type{T}) where T
     order = storageorder(A)
     C = similar(A, T, size(A))
-    x = tempunpack!(A)
-    repack! = x[end]
-    values = x[end - 1]
-    indices = x[begin:end-2]
-    newvalues = unsafe_wrap(Array, _sizedjlmalloc(length(values), T), size(values))
-    copyto!(newvalues, values)
-    newindices = _copytoraw.(indices)
-    repack!()
-    unsafepack!(C, newindices..., newvalues, false; order, decrementindices = false)
+    applyjl!(T, C, A)
 end
 # TODO: Implement this? 
 Base.convert(::Type{M}, ::AbstractGBArray; fill = nothing) where {M<:AbstractGBShallowArray} = 

src/operations/map.jl

@@ -15,6 +15,15 @@ function apply!(
     return C
 end
 
+function apply!(
+    op::DataType, C::GBVecOrMat, A::GBArrayOrTranspose;
+    mask = nothing, accum = nothing, desc = nothing
+)
+    (mask !== nothing || accum !== nothing || desc !== nothing) &&
+        throw(ArgumentError("Cannot apply! a DataType with a mask, accum, and desc."))
+    return applyjl!(op, C, A)
+end
+
 function apply!(
     op, A::GBArrayOrTranspose{T};
     mask = nothing, accum = nothing, desc = nothing

src/unpack.jl

@@ -292,8 +292,8 @@ function _unpackhypermatrix!(
     isiso == C_NULL && (isiso = false)
     nvec = nvec[]
     colptr = unsafe_wrap(Array, Ptr{Int64}(colptr[]), nvec + 1)
-    colidx = unsafe_wrap(Array, Ptr{Int64}(colidx), nvec)
-    rowidx = unsafe_wrap(Array, Ptr{Int64}(rowidx), nnonzeros)
+    colidx = unsafe_wrap(Array, Ptr{Int64}(colidx[]), nvec)
+    rowidx = unsafe_wrap(Array, Ptr{Int64}(rowidx[]), nnonzeros)
     nstored = isiso[] ? 1 : nnonzeros
     vals = unsafe_wrap(Array, Ptr{T}(values[]), nstored)
 
@@ -524,4 +524,4 @@ function tempunpack!(A::AbstractGBArray, incrementindices = false)
 end
 
 # TODO: BITMAP && HYPER
-# TODO: A reunsafepack! api?
+# TODO: A reunsafepack! api?

test/issues.jl

@@ -67,4 +67,12 @@
         x = GBMatrix([1,2], [2, 3], [1,2], fill=0)
         @test Array(x) .* [1,2] ≈ x .* [1,2]
     end
-end
+    @testset "#97" begin
+        x = GBMatrix([1,2], [2, 3], [1,2], fill=0)
+        @test SuiteSparseGraphBLAS.storedeltype(Float32.(x)) === Float32
+        @test SuiteSparseGraphBLAS.storedeltype(map(Float32, x)) === Float32
+        @test SuiteSparseGraphBLAS.storedeltype(convert(GBMatrix{Float32}, x)) === Float32
+        @test SuiteSparseGraphBLAS.storedeltype(convert(GBMatrix{Float32, Float32}, x)) === Float32
+        @test SuiteSparseGraphBLAS.storedeltype(Float32.(x .> 0)) === Float32
+    end
+end