at-deprecate spones(A) fillstored!(copy(A), 1)

NEWS.md

@@ -716,6 +716,9 @@ Deprecated or removed
  have been deprecated in favor of `spdiagm(d => x)` and `spdiagm(d[1] => x[1], d[2] => x[2], ...)`
  respectively. The new `spdiagm` implementation now always returns a square matrix ([#23757]).
 
+ * `spones(A::AbstractSparseArray)` has been deprecated in favor of
+ `LinAlg.fillstored!(copy(A), 1)` ([#25037]).
+
  * Constructors for `LibGit2.UserPasswordCredentials` and `LibGit2.SSHCredentials` which take a
  `prompt_if_incorrect` argument are deprecated. Instead, prompting behavior is controlled using
  the `allow_prompt` keyword in the `LibGit2.CredentialPayload` constructor ([#23690]).

base/deprecated.jl

@@ -1898,6 +1898,12 @@ end
 # PR #25030
 @eval LinAlg @deprecate fillslots! fillstored! false
 
+# PR #25037
+@eval SparseArrays @deprecate spones(A::SparseMatrixCSC) fillstored!(copy(A), 1)
+@eval SparseArrays @deprecate spones(A::SparseVector) fillstored!(copy(A), 1)
+using .SparseArrays.spones
+export spones
+
 function diagm(v::BitVector)
  depwarn(string("diagm(v::BitVector) is deprecated, use diagm(0 => v) or ",
  "BitMatrix(Diagonal(v)) instead"), :diagm)

base/exports.jl

@@ -1239,7 +1239,6 @@ export
  sparse,
  sparsevec,
  spdiagm,
- spones,
  sprand,
  sprandn,
  spzeros,

base/sparse/sparse.jl

@@ -7,7 +7,7 @@ module SparseArrays
 
 using Base: ReshapedArray, promote_op, setindex_shape_check, to_shape, tail
 using Base.Sort: Forward
-using Base.LinAlg: AbstractTriangular, PosDefException
+using Base.LinAlg: AbstractTriangular, PosDefException, fillstored!
 
 import Base: +, -, *, \, /, &, |, xor, ==
 import Base: A_mul_B!, Ac_mul_B, Ac_mul_B!, At_mul_B, At_mul_B!
@@ -31,7 +31,7 @@ import Base: @get!, acos, acosd, acot, acotd, acsch, asech, asin, asind, asinh,
 
 export AbstractSparseArray, AbstractSparseMatrix, AbstractSparseVector,
  SparseMatrixCSC, SparseVector, blkdiag, droptol!, dropzeros!, dropzeros,
- issparse, nonzeros, nzrange, rowvals, sparse, sparsevec, spdiagm, spones,
+ issparse, nonzeros, nzrange, rowvals, sparse, sparsevec, spdiagm,
  sprand, sprandn, spzeros, nnz, permute
 
 include("abstractsparse.jl")

base/sparse/sparsematrix.jl

@@ -1431,31 +1431,7 @@ julia> sprandn(rng, 2, 2, 0.75)
 sprandn(r::AbstractRNG, m::Integer, n::Integer, density::AbstractFloat) = sprand(r,m,n,density,randn,Float64)
 sprandn(m::Integer, n::Integer, density::AbstractFloat) = sprandn(GLOBAL_RNG,m,n,density)
 
-"""
- spones(S)
-
-Create a sparse array with the same structure as that of `S`, but with every nonzero
-element having the value `1.0`.
-
-# Examples
-```jldoctest
-julia> A = sparse([1,2,3,4],[2,4,3,1],[5.,4.,3.,2.])
-4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
- [4, 1] = 2.0
- [1, 2] = 5.0
- [3, 3] = 3.0
- [2, 4] = 4.0
-
-julia> spones(A)
-4×4 SparseMatrixCSC{Float64,Int64} with 4 stored entries:
- [4, 1] = 1.0
- [1, 2] = 1.0
- [3, 3] = 1.0
- [2, 4] = 1.0
-```
-"""
-spones(S::SparseMatrixCSC{T}) where {T} =
- SparseMatrixCSC(S.m, S.n, copy(S.colptr), copy(S.rowval), ones(T, S.colptr[end]-1))
+LinAlg.fillstored!(S::SparseMatrixCSC, x) = (fill!(view(S.nzval, 1:(S.colptr[S.n + 1] - 1)), x); S)
 
 """
  spzeros([type,]m[,n])

base/sparse/sparsevector.jl

@@ -100,8 +100,7 @@ spzeros(len::Integer) = spzeros(Float64, len)
 spzeros(::Type{T}, len::Integer) where {T} = SparseVector(len, Int[], T[])
 spzeros(::Type{Tv}, ::Type{Ti}, len::Integer) where {Tv,Ti<:Integer} = SparseVector(len, Ti[], Tv[])
 
-# Construction of same structure, but with all ones
-spones(x::SparseVector{T}) where {T} = SparseVector(x.n, copy(x.nzind), ones(T, length(x.nzval)))
+LinAlg.fillstored!(x::SparseVector, y) = (fill!(x.nzval, y); x)
 
 ### Construction from lists of indices and values
 

doc/src/manual/arrays.md

@@ -883,7 +883,6 @@ section of the standard library reference.
 | Sparse | Dense | Description |
 |:-------------------------- |:---------------------- |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [`spzeros(m,n)`](@ref) | [`zeros(m,n)`](@ref) | Creates a *m*-by-*n* matrix of zeros. ([`spzeros(m,n)`](@ref) is empty.) |
-| [`spones(S)`](@ref) | [`ones(m,n)`](@ref) | Creates a matrix filled with ones. Unlike the dense version, [`spones`](@ref) has the same sparsity pattern as *S*. |
 | [`sparse(I, n, n)`](@ref) | [`Matrix(I,n,n)`](@ref)| Creates a *n*-by-*n* identity matrix. |
 | [`Array(S)`](@ref) | [`sparse(A)`](@ref) | Interconverts between dense and sparse formats. |
 | [`sprand(m,n,d)`](@ref) | [`rand(m,n)`](@ref) | Creates a *m*-by-*n* random matrix (of density *d*) with iid non-zero elements distributed uniformly on the half-open interval ``[0, 1)``. |

doc/src/stdlib/arrays.md

@@ -198,7 +198,6 @@ Base.SparseArrays.sparsevec
 Base.SparseArrays.issparse
 Base.SparseArrays.nnz
 Base.SparseArrays.spzeros
-Base.SparseArrays.spones
 Base.SparseArrays.spdiagm
 Base.SparseArrays.sprand
 Base.SparseArrays.sprandn

test/sparse/sparse.jl

@@ -1739,8 +1739,8 @@ end
  end
 end
 
-@testset "spones" begin
- @test spones(sparse(2.0I, 5, 5)) == Matrix(I, 5, 5)
+@testset "fillstored!" begin
+ @test LinAlg.fillstored!(sparse(2.0I, 5, 5), 1) == Matrix(I, 5, 5)
 end
 
 @testset "factorization" begin
@@ -2016,7 +2016,7 @@ end
  sprand(5, 5, 1/5)
  end
  A = max.(A, A')
- A = spones(A)
+ LinAlg.fillstored!(A, 1)
  B = A[5:-1:1, 5:-1:1]
  @test issymmetric(B)
 end

test/sparse/sparsevector.jl

@@ -121,10 +121,9 @@ end
  @test exact_equal(sparsevec(d), SparseVector(3, [1, 2, 3], [0.0, 1.0, 2.0]))
  end
  end
- @testset "spones" begin
- # copies structure, but replaces nzvals with ones
+ @testset "fillstored!" begin
  x = SparseVector(8, [2, 3, 6], [12.0, 18.0, 25.0])
- y = spones(x)
+ y = LinAlg.fillstored!(copy(x), 1)
  @test (x .!= 0) == (y .!= 0)
  @test y == SparseVector(8, [2, 3, 6], [1.0, 1.0, 1.0])
  end