remove unused method sortSparseMatrixCSC!, rename sortBuffers! -> _sort_buffers!

Author: abraunst

stdlib/SparseArrays/src/sparsematrix.jl

@@ -3708,74 +3708,6 @@ function tr(A::AbstractSparseMatrixCSC{Tv}) where Tv
     return s
 end
 
-
-# Sort all the indices in each column of a CSC sparse matrix
-# sortSparseMatrixCSC!(A, sortindices = :sortcols)        # Sort each column with sort()
-# sortSparseMatrixCSC!(A, sortindices = :doubletranspose) # Sort with a double transpose
-function sortSparseMatrixCSC!(A::AbstractSparseMatrixCSC{Tv,Ti}; sortindices::Symbol = :sortcols) where {Tv,Ti}
-    if sortindices === :doubletranspose
-        nB, mB = size(A)
-        B = SparseMatrixCSC(mB, nB, Vector{Ti}(undef, nB+1), similar(rowvals(A)), similar(nonzeros(A)))
-        transpose!(B, A)
-        transpose!(A, B)
-        return A
-    end
-
-    m, n = size(A)
-    colptr = getcolptr(A); rowval = rowvals(A); nzval = nonzeros(A)
-
-    index = zeros(Ti, m)
-    row = zeros(Ti, m)
-    val = zeros(Tv, m)
-
-    perm = Base.Perm(Base.ord(isless, identity, false, Base.Order.Forward), row)
-
-    @inbounds for i = 1:n
-        nzr = nzrange(A, i)
-        numrows = length(nzr)
-        if numrows <= 1
-            continue
-        elseif numrows == 2
-            f = first(nzr)
-            s = f+1
-            if rowval[f] > rowval[s]
-                rowval[f], rowval[s] = rowval[s], rowval[f]
-                nzval[f],  nzval[s]  = nzval[s],  nzval[f]
-            end
-            continue
-        end
-        resize!(row, numrows)
-        resize!(index, numrows)
-
-        jj = 1
-        @simd for j = nzr
-            row[jj] = rowval[j]
-            val[jj] = nzval[j]
-            jj += 1
-        end
-
-        if numrows <= 16
-            alg = Base.Sort.InsertionSort
-        else
-            alg = Base.Sort.QuickSort
-        end
-
-        # Reset permutation
-        index .= 1:numrows
-
-        sort!(index, alg, perm)
-
-        jj = 1
-        @simd for j = nzr
-            rowval[j] = row[index[jj]]
-            nzval[j] = val[index[jj]]
-            jj += 1
-        end
-    end
-
-    return A
-end
-
 ## rotations
 
 function rot180(A::AbstractSparseMatrixCSC)

stdlib/SuiteSparse/src/cholmod.jl

@@ -1117,15 +1117,15 @@ function SparseMatrixCSC{Tv,SuiteSparse_long}(A::Sparse{Tv}) where Tv
             "with stype == 0 before converting to SparseMatrixCSC"))
     end
     args = _extract_args(s)
-    s.sorted == 0 && sortBuffers!(args...);
+    s.sorted == 0 && _sort_buffers!(args...);
     return _trim_nz_builder!(args...)
 end
 
 function Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}(A::Sparse{Float64})
     s = unsafe_load(pointer(A))
     issymmetric(A) || throw(ArgumentError("matrix is not symmetric"))
     args = _extract_args(s)
-    s.sorted == 0 && sortBuffers!(args...)
+    s.sorted == 0 && _sort_buffers!(args...)
     Symmetric(_trim_nz_builder!(args...), s.stype > 0 ? :U : :L)
 end
 convert(T::Type{Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}}, A::Sparse{Float64}) = T(A)
@@ -1134,7 +1134,7 @@ function Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}(A::Sparse{Tv}) where
     s = unsafe_load(pointer(A))
     ishermitian(A) || throw(ArgumentError("matrix is not Hermitian"))
     args = _extract_args(s)
-    s.sorted == 0 && sortBuffers!(args...)
+    s.sorted == 0 && _sort_buffers!(args...)
     Hermitian(_trim_nz_builder!(args...), s.stype > 0 ? :U : :L)
 end
 convert(T::Type{Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}}, A::Sparse{Tv}) where {Tv<:VTypes} = T(A)
@@ -1958,8 +1958,7 @@ end
     B::Hermitian{Float64,SparseMatrixCSC{Float64,Ti}}) where {Ti} = sparse(Sparse(A)*Sparse(B))
 
 # Sort all the indices in each column for the construction of a CSC sparse matrix
-# sortBuffers!(A, sortindices = :sortcols)        # Sort each column with sort()
-function sortBuffers!(m, n, colptr::Vector{Ti}, rowval::Vector{Ti}, nzval::Vector{Tv}) where {Ti <: Integer, Tv}
+function _sort_buffers!(m, n, colptr::Vector{Ti}, rowval::Vector{Ti}, nzval::Vector{Tv}) where {Ti <: Integer, Tv}
     index = Base.zeros(Ti, m)
     row = Base.zeros(Ti, m)
     val = Base.zeros(Tv, m)