[ViralBShah]

Stacked on #1121.

Scaling a sparse array by a Diagonal scaled only its stored entries, so an entry that is not stored stayed zero where dense computes 0 * Inf or NaN \ 0, which is NaN. #1101 fixed this for a scalar; this does it for a Diagonal, in *, \, /, rmul!, lmul!, ldiv!, rdiv!, and 3- and 5-argument mul!, for matrices, their adjoints and transposes, and Diagonal * x and ldiv!(D, x) for sparse vectors.

Before

julia> A = sparse([1.0 0; 0 1]); D = Diagonal([Inf, 1]);

julia> Matrix(A) * D
2×2 Matrix{Float64}:
  Inf  0.0
 NaN   1.0

julia> Matrix(A * D)
2×2 Matrix{Float64}:
 Inf   0.0
  0.0  1.0

julia> Matrix(rmul!(copy(A), D))
2×2 Matrix{Float64}:
 Inf   0.0
  0.0  1.0

julia> Matrix(Diagonal([NaN, 1]) \ A)   # dense: [NaN NaN; 0.0 1.0]
2×2 Matrix{Float64}:
 NaN    0.0
   0.0  1.0

After

julia> Matrix(A * D)
2×2 Matrix{Float64}:
  Inf  0.0
 NaN   1.0

julia> Matrix(rmul!(copy(A), D))
2×2 Matrix{Float64}:
  Inf  0.0
 NaN   1.0

julia> Matrix(Diagonal([NaN, 1]) \ A)
2×2 Matrix{Float64}:
 NaN    NaN
   0.0    1.0

_fullscaled finds the columns (or rows) in which op(0, d[j]) (or op(d[i], 0), with α folded in for mul!) is not zero and that are not already stored in full. When there are any, _storeinfull stores them in full, the new entries as stored zeros, and the unchanged kernels then scale those zeros as dense does. A fixed-pattern destination goes through _copyto_fixed!, so it throws with the destination unchanged when the result needs an entry it does not store, and a result too large for the index type throws before anything is written. When every diagonal entry scales zero to zero, the only extra cost is one op per diagonal entry, so the OpCount tests now count nnz + n products. An eltype without a zero keeps scaling only its stored entries, as in #1101. I swept sparse against dense locally, with Inf, -Inf and NaN (and complex ones) in the first or last diagonal entry, real and complex A with an empty row and a stored zero, and α, β in {(2, 0), (2, 3), (1, 1), (0, 2), (Inf, 0.5), (NaN, 0.5)}. Every result matches dense apart from the sign of a zero.

Timings at nnz = 10^6 (n = 10^5, finite D, minimum of 30 runs; allocations are unchanged):

	before	after
A * D	3.74 ms	3.75 ms
D * A	3.78 ms	3.78 ms
rmul!(A, D)	1.14 ms	1.18 ms
lmul!(D, A)	1.27 ms	1.29 ms
mul!(C, A, D, 2, 0)	1.48 ms	1.50 ms
D * A * D	1.82 ms	1.83 ms

Potential breakage: this changes what working code returns. A product or solve with a Diagonal that holds Inf or NaN now gives NaN in the affected columns or rows, as dense does, and stores those columns or rows in full. In-place scaling of a fixed-pattern array whose pattern does not hold them now throws an ArgumentError. The mul! docstring gains a sentence on this.

Left out: a non-finite β in 5-argument mul!, which scales the zeros of C rather than those of A. A dense C gives NaN there too.

🤖 Generated with Claude Code

[codecov]

Codecov Report

❌ Patch coverage is 85.89744% with 11 lines in your changes missing coverage. Please review.
✅ Project coverage is 94.63%. Comparing base (dd7db50) to head (eba8bc7).

Files with missing lines	Patch %	Lines
src/linalg.jl	83.58%	11 Missing ⚠️

Additional details and impacted files

@@                       Coverage Diff                       @@
##           vs/scale-into-dest-validate    #1129      +/-   ##
===============================================================
- Coverage                        94.69%   94.63%   -0.07%     
===============================================================
  Files                               16       16              
  Lines                            10318    10395      +77     
===============================================================
+ Hits                              9771     9837      +66     
- Misses                             547      558      +11     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.