1function gbtest8
2%GBTEST8 test GrB.select
3
4% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
5% SPDX-License-Identifier: GPL-3.0-or-later
6
7%   tril
8%   triu
9%   diag
10%   offdiag
11
12%   nonzero     ~=0
13%   zero        ==0
14%   positive    >0
15%   nonnegative >=0
16%   ltzero      <0
17%   lezero      <=0
18
19%   ~=
20%   ==
21%   >
22%   >=
23%   <
24%   <=
25
26rng ('default') ;
27n = 5 ;
28m = 8 ;
29A = sparse (10 * rand (m,n) - 5) .* sprand (m, n, 0.8) ;
30M = logical (sprand (m, n, 0.5)) ;
31
32b = 0.5 ;
33desc.kind = 'sparse' ;
34
35A (1,1) = b ;
36A (2,2) = -b ;
37A (3,4) = b ;
38
39%-------------------------------------------------------------------------
40% tril
41%-------------------------------------------------------------------------
42
43    C1 = tril (A) ;
44    C2 = GrB.select ('tril', A, 0) ;
45    assert (gbtest_eq (C1, C2))
46    for k = -m:n
47        C1 = tril (A, k) ;
48        C2 = GrB.select ('tril', A, k) ;
49        C3 = GrB.select ('tril', A, k, desc) ;
50        assert (gbtest_eq (C1, C2))
51        assert (gbtest_eq (C1, C3))
52        assert (isequal (class (C3), 'double')) ;
53    end
54
55    C1 = tril (A, 0) ;
56    C2 = GrB.select ('tril', A, 0) ;
57    assert (gbtest_eq (C1, C2))
58
59    C1 = A + tril (A, 0) ;
60    C2 = GrB.select (A, '+', 'tril', A, 0) ;
61    assert (gbtest_eq (C1, C2))
62
63    C1 = A ;
64    T = A + tril (A, 0) ;
65    C1 (M) = T (M) ;
66    C2 = GrB.select (A, M, '+', 'tril', A, 0) ;
67    assert (gbtest_eq (C1, C2))
68
69%-------------------------------------------------------------------------
70% triu
71%-------------------------------------------------------------------------
72
73    C1 = triu (A) ;
74    C2 = GrB.select ('triu', A, 0) ;
75    assert (gbtest_eq (C1, C2))
76    for k = -m:n
77        C1 = triu (A, k) ;
78        C2 = GrB.select ('triu', A, k) ;
79        assert (gbtest_eq (C1, C2))
80    end
81    C1 = triu (A, 0) ;
82    C2 = GrB.select ('triu', A, 0) ;
83    assert (gbtest_eq (C1, C2))
84
85%-------------------------------------------------------------------------
86% diag
87%-------------------------------------------------------------------------
88
89    d = min (m,n) ;
90    C1 = A .* spdiags (ones (d,1), 0, m, n) ;
91    C2 = GrB.select ('diag', A, 0) ;
92    assert (gbtest_eq (C1, C2))
93    for k = -m:n
94        C1 = A .* spdiags (ones (d,1), k, m, n) ;
95        C2 = GrB.select ('diag', A, k) ;
96        assert (gbtest_eq (C1, C2))
97    end
98    C1 = A .* spdiags (ones (d,1), 0, m, n) ;
99    C2 = GrB.select ('diag', A, 0) ;
100    assert (gbtest_eq (C1, C2))
101
102%-------------------------------------------------------------------------
103% offdiag
104%-------------------------------------------------------------------------
105
106    d = min (m,n) ;
107    C1 = A .* (1 - spdiags (ones (d,1), 0, m, n)) ;
108    C2 = GrB.select ('offdiag', A, 0) ;
109    assert (gbtest_eq (C1, C2))
110    for k = -m:n
111        C1 = A .* (1 - spdiags (ones (d,1), k, m, n)) ;
112        C2 = GrB.select ('offdiag', A, k) ;
113        assert (gbtest_eq (C1, C2))
114    end
115    C1 = A .* (1 - spdiags (ones (d,1), 0, m, n)) ;
116    C2 = GrB.select ('offdiag', A, 0) ;
117    assert (gbtest_eq (C1, C2))
118
119%-------------------------------------------------------------------------
120% nonzero
121%-------------------------------------------------------------------------
122
123    % all explicit entries in the MATLAB sparse matrix are nonzero,
124    % so this does nothing.  A better test would be to compute a GraphBLAS
125    % matrix with explicit zeros first.
126
127    M = (A ~= 0) ;
128    C1 = sparse (m,n) ;
129    C1 (M) = A (M) ;
130
131    C2 = GrB.select ('nonzero', A) ;
132    assert (gbtest_eq (C1, C2))
133
134    C2 = GrB.select ('~=0', A) ;
135    assert (gbtest_eq (C1, C2))
136
137    C2 = GrB.select (A, '~=0') ;
138    assert (gbtest_eq (C1, C2))
139
140%-------------------------------------------------------------------------
141% zero
142%-------------------------------------------------------------------------
143
144    % all explicit entries in the MATLAB sparse matrix are nonzero,
145    % so this does nothing.
146
147    C1 = sparse (m,n) ;
148
149    C2 = GrB.select ('zero', A) ;
150    assert (gbtest_eq (C1, C2))
151
152    C2 = GrB.select ('==0', A) ;
153    assert (gbtest_eq (C1, C2))
154
155    C2 = GrB.select (A, '==0') ;
156    assert (gbtest_eq (C1, C2))
157
158%-------------------------------------------------------------------------
159% positive
160%-------------------------------------------------------------------------
161
162    M = (A > 0) ;
163    C1 = sparse (m,n) ;
164    C1 (M) = A (M) ;
165
166    C2 = GrB.select ('positive', A) ;
167    assert (gbtest_eq (C1, C2))
168
169    C2 = GrB.select ('>0', A) ;
170    assert (gbtest_eq (C1, C2))
171
172    C2 = GrB.select (A, '>0') ;
173    assert (gbtest_eq (C1, C2))
174
175%-------------------------------------------------------------------------
176% nonnegative
177%-------------------------------------------------------------------------
178
179    M = (A >= 0) ;
180    C1 = sparse (m,n) ;
181    C1 (M) = A (M) ;
182
183    C2 = GrB.select ('nonnegative', A) ;
184    assert (gbtest_eq (C1, C2))
185
186    C2 = GrB.select ('>=0', A) ;
187    assert (gbtest_eq (C1, C2))
188
189    C2 = GrB.select (A, '>=0') ;
190    assert (gbtest_eq (C1, C2))
191
192%-------------------------------------------------------------------------
193% negative
194%-------------------------------------------------------------------------
195
196    M = (A < 0) ;
197    C1 = sparse (m,n) ;
198    C1 (M) = A (M) ;
199
200    C2 = GrB.select ('negative', A) ;
201    assert (gbtest_eq (C1, C2))
202
203    C2 = GrB.select ('<0', A) ;
204    assert (gbtest_eq (C1, C2))
205
206    C2 = GrB.select (A, '<0') ;
207    assert (gbtest_eq (C1, C2))
208
209%-------------------------------------------------------------------------
210% nonpositive
211%-------------------------------------------------------------------------
212
213    M = (A <= 0) ;
214    C1 = sparse (m,n) ;
215    C1 (M) = A (M) ;
216
217    C2 = GrB.select ('nonpositive', A) ;
218    assert (gbtest_eq (C1, C2))
219
220    C2 = GrB.select ('<=0', A) ;
221    assert (gbtest_eq (C1, C2))
222
223    C2 = GrB.select (A, '<=0') ;
224    assert (gbtest_eq (C1, C2))
225
226%-------------------------------------------------------------------------
227% ~=
228%-------------------------------------------------------------------------
229
230    M = (A ~= b) ;
231    C1 = sparse (m,n) ;
232    C1 (M) = A (M) ;
233
234    C2 = GrB.select ('~=', A, b) ;
235    assert (gbtest_eq (C1, C2))
236
237    C2 = GrB.select (A, '~=', b) ;
238    assert (gbtest_eq (C1, C2))
239
240%-------------------------------------------------------------------------
241% ==
242%-------------------------------------------------------------------------
243
244    M = (A == b) ;
245    C1 = sparse (m,n) ;
246    C1 (M) = A (M) ;
247
248    C2 = GrB.select ('==', A, b) ;
249    assert (gbtest_eq (C1, C2))
250
251    C2 = GrB.select (A, '==', b) ;
252    assert (gbtest_eq (C1, C2))
253
254%-------------------------------------------------------------------------
255% >
256%-------------------------------------------------------------------------
257
258    M = (A > b) ;
259    C1 = sparse (m,n) ;
260    C1 (M) = A (M) ;
261
262    C2 = GrB.select ('>', A, b) ;
263    assert (gbtest_eq (C1, C2))
264
265    C2 = GrB.select (A, '>', b) ;
266    assert (gbtest_eq (C1, C2))
267
268%-------------------------------------------------------------------------
269% >=
270%-------------------------------------------------------------------------
271
272    M = (A >= b) ;
273    C1 = sparse (m,n) ;
274    C1 (M) = A (M) ;
275
276    C2 = GrB.select ('>=', A, b) ;
277    assert (gbtest_eq (C1, C2))
278
279    C2 = GrB.select (A, '>=', b) ;
280    assert (gbtest_eq (C1, C2))
281
282%-------------------------------------------------------------------------
283% <
284%-------------------------------------------------------------------------
285
286    M = (A < b) ;
287    C1 = sparse (m,n) ;
288    C1 (M) = A (M) ;
289
290    C2 = GrB.select ('<', A, b) ;
291    assert (gbtest_eq (C1, C2))
292
293    C2 = GrB.select (A, '<', b) ;
294    assert (gbtest_eq (C1, C2))
295
296%-------------------------------------------------------------------------
297% <=
298%-------------------------------------------------------------------------
299
300    M = (A <= b) ;
301    C1 = sparse (m,n) ;
302    C1 (M) = A (M) ;
303
304    C2 = GrB.select ('<=', A, b) ;
305    assert (gbtest_eq (C1, C2))
306
307    C2 = GrB.select (A, '<=', b) ;
308    assert (gbtest_eq (C1, C2))
309
310%-------------------------------------------------------------------------
311% gtzero, with mask and accum
312%-------------------------------------------------------------------------
313
314    Cin = sprand (m, n, 0.5) ;
315    C2 = GrB.select (Cin, '+', '>0', A) ;
316    C1 = Cin ;
317    C1 (A > 0) = C1 (A > 0) + A (A > 0) ;
318    assert (gbtest_eq (C1, C2))
319
320    M = logical (sprand (m, n, 0.5)) ;
321    Cin = sprand (m, n, 0.5) ;
322    C2 = GrB.select (Cin, M, '>0', A) ;
323    C1 = Cin ;
324    T = sparse (m, n) ;
325    T (A > 0) = A (A > 0) ;
326    C1 (M) = T (M) ;
327    assert (gbtest_eq (C1, C2))
328
329    C2 = GrB.select (Cin, M, '+', '>0', A) ;
330    C1 = Cin ;
331    T = sparse (m, n) ;
332    T (A > 0) = A (A > 0) ;
333    C1 (M) = C1 (M) + T (M) ;
334    assert (gbtest_eq (C1, C2))
335
336fprintf ('gbtest8: all tests passed\n') ;
337
338