Skip to content

Commit 5c36d6c

Browse files
Copilotalbertomercurio
Copilot
and
albertomercurio
committed
Consolidate transpose/adjoint tests into main addition testset using iterator pattern
Co-authored-by: albertomercurio <[email protected]>
1 parent 4eb9c60 commit 5c36d6c

File tree

3 files changed

+180
-183
lines changed

3 files changed

+180
-183
lines changed

‎test/shared/matrix_coo.jl‎

Lines changed: 60 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -280,68 +280,67 @@ function shared_test_linearalgebra_matrix_coo(
280280

281281
@testset "Sparse + Sparse Matrix Addition" begin
282282
for T in (int_types..., float_types..., complex_types...)
283-
m, n = 50, 40
284-
A = sprand(T, m, n, 0.1)
285-
B = sprand(T, m, n, 0.15)
286-
287-
dA = adapt(op, DeviceSparseMatrixCOO(A))
288-
dB = adapt(op, DeviceSparseMatrixCOO(B))
289-
290-
# Test sparse + sparse
291-
result = dA + dB
292-
expected = A + B
293-
@test collect(result) ≈ Matrix(expected)
294-
@test result isa DeviceSparseMatrixCOO
295-
296-
# Test with overlapping entries
297-
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
298-
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
299-
dA_overlap = adapt(op, DeviceSparseMatrixCOO(A_overlap))
300-
dB_overlap = adapt(op, DeviceSparseMatrixCOO(B_overlap))
301-
result_overlap = dA_overlap + dB_overlap
302-
expected_overlap = A_overlap + B_overlap
303-
@test collect(result_overlap) ≈ Matrix(expected_overlap)
304-
305-
# Test dimension mismatch
306-
B_wrong = sprand(T, m + 1, n, 0.1)
307-
dB_wrong = adapt(op, DeviceSparseMatrixCOO(B_wrong))
308-
@test_throws DimensionMismatch dA + dB_wrong
309-
end
310-
end
311-
312-
@testset "Sparse + Sparse Transpose/Adjoint Addition" begin
313-
for T in (float_types..., complex_types...)
314-
m, n = 30, 30 # Square matrices for transpose tests
315-
A = sprand(T, m, n, 0.1)
316-
B = sprand(T, n, m, 0.1) # Transpose size
317-
318-
dA = adapt(op, DeviceSparseMatrixCOO(A))
319-
dB = adapt(op, DeviceSparseMatrixCOO(B))
320-
321-
# Test sparse + transpose(sparse)
322-
result_trans = dA + transpose(dB)
323-
expected_trans = A + transpose(B)
324-
@test collect(result_trans) ≈ Matrix(expected_trans)
325-
326-
# Test transpose(sparse) + sparse
327-
result_trans2 = transpose(dB) + dA
328-
@test collect(result_trans2) ≈ Matrix(expected_trans)
329-
330-
# Test sparse + adjoint(sparse) for complex types
331-
if T <: Complex
332-
result_adj = dA + adjoint(dB)
333-
expected_adj = A + adjoint(B)
334-
@test collect(result_adj) ≈ Matrix(expected_adj)
335-
336-
# Test adjoint(sparse) + sparse
337-
result_adj2 = adjoint(dB) + dA
338-
@test collect(result_adj2) ≈ Matrix(expected_adj)
283+
for (op_A, op_B) in Iterators.product(
284+
(identity, transpose, adjoint),
285+
(identity, transpose, adjoint),
286+
)
287+
# Skip identity + identity for int types when using transpose/adjoint
288+
# since we test that separately below
289+
if op_A === identity && op_B === identity
290+
# Basic addition tests
291+
m, n = 50, 40
292+
A = sprand(T, m, n, 0.1)
293+
B = sprand(T, m, n, 0.15)
294+
295+
dA = adapt(op, DeviceSparseMatrixCOO(A))
296+
dB = adapt(op, DeviceSparseMatrixCOO(B))
297+
298+
# Test sparse + sparse
299+
result = dA + dB
300+
expected = A + B
301+
@test collect(result) ≈ Matrix(expected)
302+
@test result isa DeviceSparseMatrixCOO
303+
304+
# Test with overlapping entries
305+
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
306+
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
307+
dA_overlap = adapt(op, DeviceSparseMatrixCOO(A_overlap))
308+
dB_overlap = adapt(op, DeviceSparseMatrixCOO(B_overlap))
309+
result_overlap = dA_overlap + dB_overlap
310+
expected_overlap = A_overlap + B_overlap
311+
@test collect(result_overlap) ≈ Matrix(expected_overlap)
312+
313+
# Test dimension mismatch
314+
B_wrong = sprand(T, m + 1, n, 0.1)
315+
dB_wrong = adapt(op, DeviceSparseMatrixCOO(B_wrong))
316+
@test_throws DimensionMismatch dA + dB_wrong
317+
else
318+
# Transpose/adjoint tests - only for float and complex types
319+
if T in (int_types...)
320+
continue
321+
end
322+
323+
# Skip adjoint for real types (same as transpose)
324+
if T <: Real && (op_A === adjoint || op_B === adjoint)
325+
continue
326+
end
327+
328+
# Square matrices for transpose tests
329+
m, n = 30, 30
330+
dims_A = op_A === identity ? (m, n) : (n, m)
331+
dims_B = op_B === identity ? (m, n) : (n, m)
332+
333+
A = sprand(T, dims_A..., 0.1)
334+
B = sprand(T, dims_B..., 0.1)
335+
336+
dA = adapt(op, DeviceSparseMatrixCOO(A))
337+
dB = adapt(op, DeviceSparseMatrixCOO(B))
338+
339+
result = op_A(dA) + op_B(dB)
340+
expected = op_A(A) + op_B(B)
341+
@test collect(result) ≈ Matrix(expected)
342+
end
339343
end
340-
341-
# Test transpose + transpose
342-
result_trans_trans = transpose(dA) + transpose(dA)
343-
expected_trans_trans = transpose(A) + transpose(A)
344-
@test collect(result_trans_trans) ≈ Matrix(expected_trans_trans)
345344
end
346345
end
347346

‎test/shared/matrix_csc.jl‎

Lines changed: 60 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -278,68 +278,67 @@ function shared_test_linearalgebra_matrix_csc(
278278

279279
@testset "Sparse + Sparse Matrix Addition" begin
280280
for T in (int_types..., float_types..., complex_types...)
281-
m, n = 50, 40
282-
A = sprand(T, m, n, 0.1)
283-
B = sprand(T, m, n, 0.15)
284-
285-
dA = adapt(op, DeviceSparseMatrixCSC(A))
286-
dB = adapt(op, DeviceSparseMatrixCSC(B))
287-
288-
# Test sparse + sparse
289-
result = dA + dB
290-
expected = A + B
291-
@test collect(result) ≈ Matrix(expected)
292-
@test result isa DeviceSparseMatrixCSC
293-
294-
# Test with overlapping entries
295-
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
296-
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
297-
dA_overlap = adapt(op, DeviceSparseMatrixCSC(A_overlap))
298-
dB_overlap = adapt(op, DeviceSparseMatrixCSC(B_overlap))
299-
result_overlap = dA_overlap + dB_overlap
300-
expected_overlap = A_overlap + B_overlap
301-
@test collect(result_overlap) ≈ Matrix(expected_overlap)
302-
303-
# Test dimension mismatch
304-
B_wrong = sprand(T, m + 1, n, 0.1)
305-
dB_wrong = adapt(op, DeviceSparseMatrixCSC(B_wrong))
306-
@test_throws DimensionMismatch dA + dB_wrong
307-
end
308-
end
309-
310-
@testset "Sparse + Sparse Transpose/Adjoint Addition" begin
311-
for T in (float_types..., complex_types...)
312-
m, n = 30, 30 # Square matrices for transpose tests
313-
A = sprand(T, m, n, 0.1)
314-
B = sprand(T, n, m, 0.1) # Transpose size
315-
316-
dA = adapt(op, DeviceSparseMatrixCSC(A))
317-
dB = adapt(op, DeviceSparseMatrixCSC(B))
318-
319-
# Test sparse + transpose(sparse)
320-
result_trans = dA + transpose(dB)
321-
expected_trans = A + transpose(B)
322-
@test collect(result_trans) ≈ Matrix(expected_trans)
323-
324-
# Test transpose(sparse) + sparse
325-
result_trans2 = transpose(dB) + dA
326-
@test collect(result_trans2) ≈ Matrix(expected_trans)
327-
328-
# Test sparse + adjoint(sparse) for complex types
329-
if T <: Complex
330-
result_adj = dA + adjoint(dB)
331-
expected_adj = A + adjoint(B)
332-
@test collect(result_adj) ≈ Matrix(expected_adj)
333-
334-
# Test adjoint(sparse) + sparse
335-
result_adj2 = adjoint(dB) + dA
336-
@test collect(result_adj2) ≈ Matrix(expected_adj)
281+
for (op_A, op_B) in Iterators.product(
282+
(identity, transpose, adjoint),
283+
(identity, transpose, adjoint),
284+
)
285+
# Skip identity + identity for int types when using transpose/adjoint
286+
# since we test that separately below
287+
if op_A === identity && op_B === identity
288+
# Basic addition tests
289+
m, n = 50, 40
290+
A = sprand(T, m, n, 0.1)
291+
B = sprand(T, m, n, 0.15)
292+
293+
dA = adapt(op, DeviceSparseMatrixCSC(A))
294+
dB = adapt(op, DeviceSparseMatrixCSC(B))
295+
296+
# Test sparse + sparse
297+
result = dA + dB
298+
expected = A + B
299+
@test collect(result) ≈ Matrix(expected)
300+
@test result isa DeviceSparseMatrixCSC
301+
302+
# Test with overlapping entries
303+
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
304+
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
305+
dA_overlap = adapt(op, DeviceSparseMatrixCSC(A_overlap))
306+
dB_overlap = adapt(op, DeviceSparseMatrixCSC(B_overlap))
307+
result_overlap = dA_overlap + dB_overlap
308+
expected_overlap = A_overlap + B_overlap
309+
@test collect(result_overlap) ≈ Matrix(expected_overlap)
310+
311+
# Test dimension mismatch
312+
B_wrong = sprand(T, m + 1, n, 0.1)
313+
dB_wrong = adapt(op, DeviceSparseMatrixCSC(B_wrong))
314+
@test_throws DimensionMismatch dA + dB_wrong
315+
else
316+
# Transpose/adjoint tests - only for float and complex types
317+
if T in (int_types...)
318+
continue
319+
end
320+
321+
# Skip adjoint for real types (same as transpose)
322+
if T <: Real && (op_A === adjoint || op_B === adjoint)
323+
continue
324+
end
325+
326+
# Square matrices for transpose tests
327+
m, n = 30, 30
328+
dims_A = op_A === identity ? (m, n) : (n, m)
329+
dims_B = op_B === identity ? (m, n) : (n, m)
330+
331+
A = sprand(T, dims_A..., 0.1)
332+
B = sprand(T, dims_B..., 0.1)
333+
334+
dA = adapt(op, DeviceSparseMatrixCSC(A))
335+
dB = adapt(op, DeviceSparseMatrixCSC(B))
336+
337+
result = op_A(dA) + op_B(dB)
338+
expected = op_A(A) + op_B(B)
339+
@test collect(result) ≈ Matrix(expected)
340+
end
337341
end
338-
339-
# Test transpose + transpose
340-
result_trans_trans = transpose(dA) + transpose(dA)
341-
expected_trans_trans = transpose(A) + transpose(A)
342-
@test collect(result_trans_trans) ≈ Matrix(expected_trans_trans)
343342
end
344343
end
345344

‎test/shared/matrix_csr.jl‎

Lines changed: 60 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -277,68 +277,67 @@ function shared_test_linearalgebra_matrix_csr(
277277

278278
@testset "Sparse + Sparse Matrix Addition" begin
279279
for T in (int_types..., float_types..., complex_types...)
280-
m, n = 50, 40
281-
A = sprand(T, m, n, 0.1)
282-
B = sprand(T, m, n, 0.15)
283-
284-
dA = adapt(op, DeviceSparseMatrixCSR(A))
285-
dB = adapt(op, DeviceSparseMatrixCSR(B))
286-
287-
# Test sparse + sparse
288-
result = dA + dB
289-
expected = A + B
290-
@test collect(result) ≈ Matrix(expected)
291-
@test result isa DeviceSparseMatrixCSR
292-
293-
# Test with overlapping entries
294-
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
295-
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
296-
dA_overlap = adapt(op, DeviceSparseMatrixCSR(A_overlap))
297-
dB_overlap = adapt(op, DeviceSparseMatrixCSR(B_overlap))
298-
result_overlap = dA_overlap + dB_overlap
299-
expected_overlap = A_overlap + B_overlap
300-
@test collect(result_overlap) ≈ Matrix(expected_overlap)
301-
302-
# Test dimension mismatch
303-
B_wrong = sprand(T, m + 1, n, 0.1)
304-
dB_wrong = adapt(op, DeviceSparseMatrixCSR(B_wrong))
305-
@test_throws DimensionMismatch dA + dB_wrong
306-
end
307-
end
308-
309-
@testset "Sparse + Sparse Transpose/Adjoint Addition" begin
310-
for T in (float_types..., complex_types...)
311-
m, n = 30, 30 # Square matrices for transpose tests
312-
A = sprand(T, m, n, 0.1)
313-
B = sprand(T, n, m, 0.1) # Transpose size
314-
315-
dA = adapt(op, DeviceSparseMatrixCSR(A))
316-
dB = adapt(op, DeviceSparseMatrixCSR(B))
317-
318-
# Test sparse + transpose(sparse)
319-
result_trans = dA + transpose(dB)
320-
expected_trans = A + transpose(B)
321-
@test collect(result_trans) ≈ Matrix(expected_trans)
322-
323-
# Test transpose(sparse) + sparse
324-
result_trans2 = transpose(dB) + dA
325-
@test collect(result_trans2) ≈ Matrix(expected_trans)
326-
327-
# Test sparse + adjoint(sparse) for complex types
328-
if T <: Complex
329-
result_adj = dA + adjoint(dB)
330-
expected_adj = A + adjoint(B)
331-
@test collect(result_adj) ≈ Matrix(expected_adj)
332-
333-
# Test adjoint(sparse) + sparse
334-
result_adj2 = adjoint(dB) + dA
335-
@test collect(result_adj2) ≈ Matrix(expected_adj)
280+
for (op_A, op_B) in Iterators.product(
281+
(identity, transpose, adjoint),
282+
(identity, transpose, adjoint),
283+
)
284+
# Skip identity + identity for int types when using transpose/adjoint
285+
# since we test that separately below
286+
if op_A === identity && op_B === identity
287+
# Basic addition tests
288+
m, n = 50, 40
289+
A = sprand(T, m, n, 0.1)
290+
B = sprand(T, m, n, 0.15)
291+
292+
dA = adapt(op, DeviceSparseMatrixCSR(A))
293+
dB = adapt(op, DeviceSparseMatrixCSR(B))
294+
295+
# Test sparse + sparse
296+
result = dA + dB
297+
expected = A + B
298+
@test collect(result) ≈ Matrix(expected)
299+
@test result isa DeviceSparseMatrixCSR
300+
301+
# Test with overlapping entries
302+
A_overlap = sparse([1, 2, 3], [1, 2, 3], T[1, 2, 3], m, n)
303+
B_overlap = sparse([1, 2, 4], [1, 2, 4], T[4, 5, 6], m, n)
304+
dA_overlap = adapt(op, DeviceSparseMatrixCSR(A_overlap))
305+
dB_overlap = adapt(op, DeviceSparseMatrixCSR(B_overlap))
306+
result_overlap = dA_overlap + dB_overlap
307+
expected_overlap = A_overlap + B_overlap
308+
@test collect(result_overlap) ≈ Matrix(expected_overlap)
309+
310+
# Test dimension mismatch
311+
B_wrong = sprand(T, m + 1, n, 0.1)
312+
dB_wrong = adapt(op, DeviceSparseMatrixCSR(B_wrong))
313+
@test_throws DimensionMismatch dA + dB_wrong
314+
else
315+
# Transpose/adjoint tests - only for float and complex types
316+
if T in (int_types...)
317+
continue
318+
end
319+
320+
# Skip adjoint for real types (same as transpose)
321+
if T <: Real && (op_A === adjoint || op_B === adjoint)
322+
continue
323+
end
324+
325+
# Square matrices for transpose tests
326+
m, n = 30, 30
327+
dims_A = op_A === identity ? (m, n) : (n, m)
328+
dims_B = op_B === identity ? (m, n) : (n, m)
329+
330+
A = sprand(T, dims_A..., 0.1)
331+
B = sprand(T, dims_B..., 0.1)
332+
333+
dA = adapt(op, DeviceSparseMatrixCSR(A))
334+
dB = adapt(op, DeviceSparseMatrixCSR(B))
335+
336+
result = op_A(dA) + op_B(dB)
337+
expected = op_A(A) + op_B(B)
338+
@test collect(result) ≈ Matrix(expected)
339+
end
336340
end
337-
338-
# Test transpose + transpose
339-
result_trans_trans = transpose(dA) + transpose(dA)
340-
expected_trans_trans = transpose(A) + transpose(A)
341-
@test collect(result_trans_trans) ≈ Matrix(expected_trans_trans)
342341
end
343342
end
344343

0 commit comments

Comments
 (0)