defragile umfpack, passes tests, diagonal ctors, few bugfixes

Author: rayegun

src/abstractgbarray.jl

@@ -678,20 +678,33 @@ function LinearAlgebra.diag(A::AbstractGBMatrix{T}, k::Integer = 0; desc = nothi
     if A isa Transpose
         k = -k
     end
-    @wraperror LibGraphBLAS.GxB_Vector_diag(LibGraphBLAS.GrB_Vector(v), parent(A), k, desc)
-    return v
+    @wraperror LibGraphBLAS.GxB_Vector_diag(v, parent(A), k, desc)
+    return Vector(v)
 end
 
-# This does not conform to the normal definition with a lazy wrapper.
-function LinearAlgebra.Diagonal(v::AbstractGBVector, k::Integer=0; desc = nothing)
-    s = size(v, 1)
-    C = GBMatrix{storedeltype(v)}(s, s; fill = v.fill)
+function GBDiagonal!(C::AbstractGBMatrix, v::AbstractGBVector, k::Integer=0; desc = nothing)
     desc = _handledescriptor(desc)
-    # Switch ptr to a Vector to trick GraphBLAS.
-    # This is allowed since GrB_Vector is a GrB_Matrix internally.
-    @wraperror LibGraphBLAS.GxB_Matrix_diag(C, LibGraphBLAS.GrB_Vector(v.p[]), k, desc)
+    @wraperror LibGraphBLAS.GxB_Matrix_diag(C, v, k, desc)
     return C
 end
+function GBDiagonal!(C::AbstractGBMatrix{T}, v::AbstractVector, k::Integer=0; desc = nothing) where T
+    v2 = GBShallowVector(convert(DenseVector{T}, v))
+    GBDiagonal!(C, v2, k; desc)
+end
+function GBDiagonal!(C::AbstractGBMatrix, D::Diagonal; desc = nothing)
+    GBDiagonal!(C, D.diag; desc)
+end
+function GBDiagonal(v, k::Integer=0; desc = nothing)
+    s = size(v, 1)
+    C = GBMatrix{storedeltype(v)}(s, s; fill = defaultfill(storedeltype(v)))
+    GBDiagonal!(C, v, k; desc)
+end
+function GBDiagonal(v::AbstractGBVector, k::Integer=0; desc = nothing)
+    s = size(v, 1)
+    C = GBMatrix{storedeltype(v)}(s, s; fill = getfill(v))
+    GBDiagonal!(C, v, k; desc)
+end
+
 
 # Type dependent functions build, setindex, getindex, and findnz:
 for T ∈ valid_vec

src/operations/mul.jl

@@ -188,3 +188,15 @@ function Base.:*(rig::TypedSemiring)
         *(A, B, rig; mask, accum, desc)
     end
 end
+
+# Diagonal
+function Base.:*(D::Diagonal, A::G) where 
+    {G <: Union{Transpose{T, <:SuiteSparseGraphBLAS.AbstractGBArray{T1, F, O}} where {T, T1, F, O}, 
+        SuiteSparseGraphBLAS.AbstractGBArray{T, F, O, 2} where {T, F, O}}}
+    return *(G(D), A)
+end
+function Base.:*(A::G, D::Diagonal) where 
+    {G <: Union{Transpose{T, <:SuiteSparseGraphBLAS.AbstractGBArray{T1, F, O}} where {T, T1, F, O}, 
+        SuiteSparseGraphBLAS.AbstractGBArray{T, F, O, 2} where {T, F, O}}}
+    return *(G(D), A)
+end

src/options.jl

@@ -103,6 +103,7 @@ Return the current sparsity of `A`, which is one of `Dense`,
 `Bitmap`, `Sparse`, or `Hypersparse`.
 """
 function sparsitystatus(A::AbstractGBArray)
+    wait(A) # We need to do this to ensure we're actually unpacking correctly.
     t = GBSparsity(gbget(A, SPARSITY_STATUS))
     return consttoshape(t)
 end

src/pack.jl

@@ -120,7 +120,7 @@ function _packcsrmatrix!(
     ) where {T, Ti}
     if decrementindices && rowptr[begin] == 1
         decrement!(rowptr)
-        decrement(colidx)
+        decrement!(colidx)
     end
 
     rowpointer = pointer(rowptr)
@@ -147,8 +147,8 @@ end
 
 function _packhypermatrix!(
     A::AbstractGBArray{T}, ptr::Vector{Ti}, idx1::Vector{Ti}, idx2::Vector{Ti}, values::Vector{T};
-    desc = nothing, order = ColMajor()
-) where {T}
+    desc = nothing, order = ColMajor(), decrementindices = true
+) where {T, Ti}
     desc = _handledescriptor(desc)
     valsize = length(A) * sizeof(T)
     ptrsize = length(ptr) * sizeof(Ti)
@@ -160,7 +160,11 @@ function _packhypermatrix!(
     idx1pointer = Ref{Ptr{LibGraphBLAS.GrB_Index}}(pointer(idx1))
     idx2pointer = Ref{Ptr{LibGraphBLAS.GrB_Index}}(pointer(idx2))
     valpointer = Ref{Ptr{Cvoid}}(pointer(values))
-
+    if decrementindices
+        decrement!(ptr)
+        decrement!(idx1)
+        decrement!(idx2)
+    end
     if order === ColMajor()
         @wraperror LibGraphBLAS.GxB_Matrix_pack_HyperCSC(
             A,
@@ -241,7 +245,7 @@ function unsafepack!(
     A::AbstractGBArray, ptr, idx1, idx2, values, shallow::Bool = true;
     order = ColMajor(), decrementindices = true
 )
-    _packhypermatrix!(A, ptr, idx1, idx2, values; decrementindices)
+    _packhypermatrix!(A, ptr, idx1, idx2, values; order, decrementindices)
     shallow && makeshallow!(A)
     LibGraphBLAS.GxB_Matrix_Option_set(A, LibGraphBLAS.GxB_FORMAT, option_toconst(storageorder(A)))
     return A

src/shallowtypes.jl

@@ -1,20 +1,20 @@
 # fall back to nzval, this may need to change eventually, as it's currently not possible to know the storage order.
 # Either a new parameter or something else.
-function GBShallowVector(v::DenseVector{T}; fill::F = nothing) where {T, F}
+function GBShallowVector(v::DenseVector{T}; fill::F = defaultfill(T)) where {T, F}
     m = _newGrBRef()
     @wraperror LibGraphBLAS.GrB_Matrix_new(m, gbtype(T), size(v, 1), size(v, 2))
     gbvec = GBShallowVector{T}(m, fill, Int64[], Int64[], Int64[], Bool[], v)
     unsafepack!(gbvec, v, true)
 end
 
-function GBShallowMatrix(M::StridedMatrix{T}; fill::F = nothing) where {T, F}
+function GBShallowMatrix(M::StridedMatrix{T}; fill::F = defaultfill(T)) where {T, F}
     m = _newGrBRef()
     @wraperror LibGraphBLAS.GrB_Matrix_new(m, gbtype(T), size(M)...)
     gbmat = GBShallowMatrix{T}(m, fill, Int64[], Int64[], Int64[], Bool[], M)
     unsafepack!(gbmat, M, true)
 end
 
-function GBShallowVector(idx::DenseVector{I}, nzvals::DenseVector{T}, size; fill::F = nothing, decrementindices = true) where {I<:Integer, T, F}
+function GBShallowVector(idx::DenseVector{I}, nzvals::DenseVector{T}, size; fill::F = defaultfill(T), decrementindices = true) where {I<:Integer, T, F}
     I isa Integer && sizeo(I) == 8 || throw(ArgumentError("$I is not a 64 bit signed or unsigned Integer."))
     m = _newGrBRef()
     @wraperror LibGraphBLAS.GrB_Matrix_new(m, gbtype(T), size, 1)
@@ -27,15 +27,15 @@ GBShallowVector(v::SparseVector; fill = nothing, decrementindices = true) = retu
     fill, decrementindices
 )
 
-function GBShallowMatrix(ptr::DenseVector{I}, idx::DenseVector{I}, nzvals::DenseVector{T}, nrows, ncols; fill::F = nothing, decrementindices = true) where {I<:Integer, T, F}
+function GBShallowMatrix(ptr::DenseVector{I}, idx::DenseVector{I}, nzvals::DenseVector{T}, nrows, ncols; fill::F = defaultfill(T), decrementindices = true) where {I<:Integer, T, F}
     I isa Integer && sizeo(I) == 8 || throw(ArgumentError("$I is not a 64 bit signed or unsigned Integer."))
     m = _newGrBRef()
     @wraperror LibGraphBLAS.GrB_Matrix_new(m, gbtype(T), nrows, ncols)
     gbmat = GBShallowMatrix{T}(m, fill, ptr, idx, Int64[], Bool[], nzvals)
     unsafepack!(gbmat, gbmat.ptr, gbmat.idx, gbmat.nzval, true; decrementindices)
 end
 
-GBShallowMatrix(S::SparseMatrixCSC; fill = nothing, decrementindices = true) = GBShallowMatrix(
+GBShallowMatrix(S::SparseMatrixCSC{T}; fill = defaultfill(T), decrementindices = true) where T = GBShallowMatrix(
     S.colptr, S.rowval, s.nzval, size(S, 1), size(S, 2);
     fill, decrementindices
 )