Specialize Diagonal products and dot for adjoint/transpose of sparse matrices

[ViralBShah]

Fixes #619 and #627. Both are cases where a lazy Adjoint/Transpose of a SparseMatrixCSC fell through to a generic method that ignores sparsity.

#619: mul! of an adjoint/transpose of a sparse matrix with a Diagonal

LinearAlgebra's Diagonal kernel visits every element of the destination, so mul!(C, S', D), mul!(C, D, S') and their 5-argument forms were O(m·n). New 5-argument mul! methods form the adjoint directly in C with one halfperm! and scale it in place, falling back to a materialized copy when beta is nonzero or when C shares storage with the parent, is fixed, or has another index type. * reaches these through matop_dest, which now hands the adjoint of a sparse matrix an empty writable destination (with a size hint) and a fixed sparse matrix a fixed destination with its own structure. As a result D * F and F' * D for a fixed F no longer fail with "Can't change ReadOnly"; F * D and D * F' already worked.

On nightly (N=1000, density 0.1, min of 7):

Call	main	this PR
mul!(C, A', D)	43.8 ms	0.19 ms
mul!(C, D, A')	44.7 ms	0.23 ms
mul!(C, A', D, 2, 3)	49.6 ms	0.55 ms
A' * D, D * A'	~0.5 ms	~0.5 ms

* is unchanged on nightly, where the generic path already materializes the adjoint; the explicit methods make it independent of LinearAlgebra internals.

#627: dot(A', B) for sparse A, B

The existing wrapper method walks the stored entries of B and does a binary search into A' for each one. The new method walks the sparser operand and keeps one cursor per column of the other, so it runs in O(nnz(A) + nnz(B) + n) time with O(n) extra memory and no O(nnz) temporary. Since the cursors sweep every stored entry of the other operand, it switches to a binary search per entry once the other operand holds over 32x more entries (or columns) than the walked one; the measured crossover is a ratio of 20-50. It returns early when either operand has no stored entries, so two nearly empty operands with 10^7 rows cost nothing. dot(B, A') reaches the same kernel through the existing conj(dot(A', B)).

Call (N=1000, min of 7)	main	this PR
dot(A', B), both density 0.1	2.27 ms	1.06 ms
dot(copy(A'), B)	1.1-1.5 ms	unchanged
dot(P', Bd), nnz(P)=2e3, nnz(Bd)=5e5	4.4 ms	24 µs
dot(Bd', P)	26 µs	26 µs

Semantics shared with dense and with the existing CSC kernels

Review of the first version found the direct adjoint path diverging from mul! on dense arrays and from the plain CSC kernels, so the four Diagonal kernels now agree with both:

• The product is formed in the promoted eltype and converted once. The direct path is taken only when the destination eltype is the product's; a Float32 or Int destination goes through the materialized copy and the CSC kernel, so mul!(spzeros(Float32,1,1), sparse([1e40;;])', Diagonal([1e-40])) is 1f0 and an Int destination takes 0.5 * 2.0 without an InexactError, as on main.
• alpha == 0 ignores A and beta == 0 ignores C, so nonfinite entries in either do not leak into the result. This was already wrong in the plain CSC kernels on main, which returned NaN for mul!(C, sparse([Inf;;]), D, 0, 0); they are fixed here too so that the adjoint and plain paths agree.
• A fixed destination whose pattern contains the product's is filled in place, for plain and adjoint operands and both operand orders; main only handled the adjoint case, through the generic kernel, and threw from copyinds! for a plain operand. A fixed destination lacking an entry throws an ArgumentError naming the entry, with the destination untouched, where main threw a MethodError from insert!.
• The dot walk picks the operand with fewer stored entries plus columns, because the walk visits every column of the operand it walks. A 1×10⁶ parent with one stored entry against a 10⁶×1 operand with two went from 0.2 µs on main to 627 µs with the first version, and is back to 0.2 µs.

Dispatch is touched: three matop_dest methods and the mul! and dot methods above are new. Not a backport candidate, since it adds methods.

Tests

Wall-clock guards are replaced by a multiplication-counting eltype (test/util/mulcount.jl): the kernels perform exactly nnz multiplications, and dot only multiplies where both operands store an entry, from either side of the walk. Also covered: fixed operands, the 3- and 5-argument mul! forms, a destination that aliases or shares storage with the parent, another index type, both dot branches, stored zeros, empty columns, non-square shapes and dimension errors. Test.detect_ambiguities(SparseArrays; recursive=true) is empty. The dense-consistency cases above are tested for the plain, adjoint and transposed operand in both orders; test/linalg.jl, test/linalg_products.jl and test/fixed.jl pass on nightly.

🤖 Generated with Claude Code

https://claude.ai/code/session_015VF52nADauBDqAQaUHjoNV

[codecov]

Codecov Report

❌ Patch coverage is 92.95775% with 5 lines in your changes missing coverage. Please review.
✅ Project coverage is 92.61%. Comparing base (65ba486) to head (da8de50).
⚠️ Report is 3 commits behind head on main.

Files with missing lines	Patch %	Lines
src/linalg.jl	92.75%	5 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #770      +/-   ##
==========================================
+ Coverage   92.59%   92.61%   +0.02%     
==========================================
  Files          12       12              
  Lines        8780     8848      +68     
==========================================
+ Hits         8130     8195      +65     
- Misses        650      653       +3     

☔ 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.

[Copilot]

🟢 Approval recommended

The implementations are consistent with existing sparse kernels and comprehensively tested.

Pull request overview

Adds sparse specializations for lazy adjoint/transpose operations, resolving performance regressions in diagonal multiplication and Frobenius dot products.

Changes:

• Materializes sparse wrappers before diagonal scaling.
• Implements a linear-time cursor-based sparse dot kernel.
• Adds correctness, edge-case, and performance tests.

File summaries

File	Description
src/linalg.jl	Adds specialized multiplication and dot methods.
test/linalg.jl	Tests diagonal products and performance.
test/linalg_products.jl	Tests sparse wrapper dot products and edge cases.

Review details

• Files reviewed: 3/3 changed files
• Comments generated: 0
• Review effort level: Balanced

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.